/**
 * 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 Expert
 * 
 */
export type Expert = $Result.DefaultSelection<Prisma.$ExpertPayload>
/**
 * Model id_verification
 * 
 */
export type id_verification = $Result.DefaultSelection<Prisma.$id_verificationPayload>
/**
 * Model email_verification_token
 * 
 */
export type email_verification_token = $Result.DefaultSelection<Prisma.$email_verification_tokenPayload>
/**
 * Model Question
 * 
 */
export type Question = $Result.DefaultSelection<Prisma.$QuestionPayload>
/**
 * Model Reply
 * 
 */
export type Reply = $Result.DefaultSelection<Prisma.$ReplyPayload>
/**
 * Model StripeAccount
 * 
 */
export type StripeAccount = $Result.DefaultSelection<Prisma.$StripeAccountPayload>
/**
 * Model Key
 * 
 */
export type Key = $Result.DefaultSelection<Prisma.$KeyPayload>
/**
 * Model Experience
 * 
 */
export type Experience = $Result.DefaultSelection<Prisma.$ExperiencePayload>
/**
 * Model Education
 * 
 */
export type Education = $Result.DefaultSelection<Prisma.$EducationPayload>
/**
 * Model Expertise
 * 
 */
export type Expertise = $Result.DefaultSelection<Prisma.$ExpertisePayload>
/**
 * Model Language
 * 
 */
export type Language = $Result.DefaultSelection<Prisma.$LanguagePayload>
/**
 * Model Appointment
 * 
 */
export type Appointment = $Result.DefaultSelection<Prisma.$AppointmentPayload>
/**
 * Model Availability
 * 
 */
export type Availability = $Result.DefaultSelection<Prisma.$AvailabilityPayload>
/**
 * Model Slot
 * 
 */
export type Slot = $Result.DefaultSelection<Prisma.$SlotPayload>
/**
 * Model Exception
 * 
 */
export type Exception = $Result.DefaultSelection<Prisma.$ExceptionPayload>
/**
 * Model Chat
 * 
 */
export type Chat = $Result.DefaultSelection<Prisma.$ChatPayload>
/**
 * Model ChatMessage
 * 
 */
export type ChatMessage = $Result.DefaultSelection<Prisma.$ChatMessagePayload>
/**
 * Model ClientReview
 * 
 */
export type ClientReview = $Result.DefaultSelection<Prisma.$ClientReviewPayload>
/**
 * Model ExpertReview
 * 
 */
export type ExpertReview = $Result.DefaultSelection<Prisma.$ExpertReviewPayload>
/**
 * Model admin_invite_experts
 * 
 */
export type admin_invite_experts = $Result.DefaultSelection<Prisma.$admin_invite_expertsPayload>
/**
 * Model admin_mbc_cms
 * This model or at least one of its fields has comments in the database, and requires an additional setup for migrations: Read more: https://pris.ly/d/database-comments
 */
export type admin_mbc_cms = $Result.DefaultSelection<Prisma.$admin_mbc_cmsPayload>
/**
 * Model admin_mbc_faqs
 * This model or at least one of its fields has comments in the database, and requires an additional setup for migrations: Read more: https://pris.ly/d/database-comments
 */
export type admin_mbc_faqs = $Result.DefaultSelection<Prisma.$admin_mbc_faqsPayload>
/**
 * Model admin_newsletter
 * 
 */
export type admin_newsletter = $Result.DefaultSelection<Prisma.$admin_newsletterPayload>
/**
 * Model admin_user
 * 
 */
export type admin_user = $Result.DefaultSelection<Prisma.$admin_userPayload>
/**
 * Model faqQuestion
 * 
 */
export type faqQuestion = $Result.DefaultSelection<Prisma.$faqQuestionPayload>
/**
 * Model session
 * 
 */
export type session = $Result.DefaultSelection<Prisma.$sessionPayload>
/**
 * Model admin_editing
 * 
 */
export type admin_editing = $Result.DefaultSelection<Prisma.$admin_editingPayload>
/**
 * Model admin_notification
 * 
 */
export type admin_notification = $Result.DefaultSelection<Prisma.$admin_notificationPayload>
/**
 * Model admin_notification_status
 * 
 */
export type admin_notification_status = $Result.DefaultSelection<Prisma.$admin_notification_statusPayload>
/**
 * Model expertApplicationAnswer
 * 
 */
export type expertApplicationAnswer = $Result.DefaultSelection<Prisma.$expertApplicationAnswerPayload>
/**
 * Model admin_expert_application
 * 
 */
export type admin_expert_application = $Result.DefaultSelection<Prisma.$admin_expert_applicationPayload>
/**
 * Model expertApplicationQuestion
 * 
 */
export type expertApplicationQuestion = $Result.DefaultSelection<Prisma.$expertApplicationQuestionPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const CountryCode: {
  UNK: 'UNK',
  AD: 'AD',
  AE: 'AE',
  AF: 'AF',
  AG: 'AG',
  AI: 'AI',
  AL: 'AL',
  AM: 'AM',
  AN: 'AN',
  AO: 'AO',
  AQ: 'AQ',
  AR: 'AR',
  AS: 'AS',
  AT: 'AT',
  AU: 'AU',
  AW: 'AW',
  AX: 'AX',
  AZ: 'AZ',
  BA: 'BA',
  BB: 'BB',
  BD: 'BD',
  BE: 'BE',
  BF: 'BF',
  BG: 'BG',
  BH: 'BH',
  BI: 'BI',
  BJ: 'BJ',
  BL: 'BL',
  BM: 'BM',
  BN: 'BN',
  BO: 'BO',
  BQ: 'BQ',
  BR: 'BR',
  BS: 'BS',
  BT: 'BT',
  BV: 'BV',
  BW: 'BW',
  BY: 'BY',
  BZ: 'BZ',
  CA: 'CA',
  CC: 'CC',
  CD: 'CD',
  CF: 'CF',
  CG: 'CG',
  CH: 'CH',
  CI: 'CI',
  CK: 'CK',
  CL: 'CL',
  CM: 'CM',
  CN: 'CN',
  CO: 'CO',
  CR: 'CR',
  CU: 'CU',
  CV: 'CV',
  CW: 'CW',
  CX: 'CX',
  CY: 'CY',
  CZ: 'CZ',
  DE: 'DE',
  DJ: 'DJ',
  DK: 'DK',
  DM: 'DM',
  DO: 'DO',
  DZ: 'DZ',
  EC: 'EC',
  EE: 'EE',
  EG: 'EG',
  EH: 'EH',
  ER: 'ER',
  ES: 'ES',
  ET: 'ET',
  EU: 'EU',
  FI: 'FI',
  FJ: 'FJ',
  FK: 'FK',
  FM: 'FM',
  FO: 'FO',
  FR: 'FR',
  GA: 'GA',
  GB_ENG: 'GB_ENG',
  GB_NIR: 'GB_NIR',
  GB_SCT: 'GB_SCT',
  GB_WLS: 'GB_WLS',
  GB: 'GB',
  GD: 'GD',
  GE: 'GE',
  GF: 'GF',
  GG: 'GG',
  GH: 'GH',
  GI: 'GI',
  GL: 'GL',
  GM: 'GM',
  GN: 'GN',
  GP: 'GP',
  GQ: 'GQ',
  GR: 'GR',
  GS: 'GS',
  GT: 'GT',
  GU: 'GU',
  GW: 'GW',
  GY: 'GY',
  HK: 'HK',
  HM: 'HM',
  HN: 'HN',
  HR: 'HR',
  HT: 'HT',
  HU: 'HU',
  ID: 'ID',
  IE: 'IE',
  IL: 'IL',
  IM: 'IM',
  IN: 'IN',
  IO: 'IO',
  IQ: 'IQ',
  IR: 'IR',
  IS: 'IS',
  IT: 'IT',
  JE: 'JE',
  JM: 'JM',
  JO: 'JO',
  JP: 'JP',
  KE: 'KE',
  KG: 'KG',
  KH: 'KH',
  KI: 'KI',
  KM: 'KM',
  KN: 'KN',
  KP: 'KP',
  KR: 'KR',
  KW: 'KW',
  KY: 'KY',
  KZ: 'KZ',
  LA: 'LA',
  LB: 'LB',
  LC: 'LC',
  LI: 'LI',
  LK: 'LK',
  LR: 'LR',
  LS: 'LS',
  LT: 'LT',
  LU: 'LU',
  LV: 'LV',
  LY: 'LY',
  MA: 'MA',
  MC: 'MC',
  MD: 'MD',
  ME: 'ME',
  MF: 'MF',
  MG: 'MG',
  MH: 'MH',
  MK: 'MK',
  ML: 'ML',
  MM: 'MM',
  MN: 'MN',
  MO: 'MO',
  MP: 'MP',
  MQ: 'MQ',
  MR: 'MR',
  MS: 'MS',
  MT: 'MT',
  MU: 'MU',
  MV: 'MV',
  MW: 'MW',
  MX: 'MX',
  MY: 'MY',
  MZ: 'MZ',
  NA: 'NA',
  NC: 'NC',
  NE: 'NE',
  NF: 'NF',
  NG: 'NG',
  NI: 'NI',
  NL: 'NL',
  NO: 'NO',
  NP: 'NP',
  NR: 'NR',
  NU: 'NU',
  NZ: 'NZ',
  OM: 'OM',
  PA: 'PA',
  PE: 'PE',
  PF: 'PF',
  PG: 'PG',
  PH: 'PH',
  PK: 'PK',
  PL: 'PL',
  PM: 'PM',
  PN: 'PN',
  PR: 'PR',
  PS: 'PS',
  PT: 'PT',
  PW: 'PW',
  PY: 'PY',
  QA: 'QA',
  RE: 'RE',
  RO: 'RO',
  RS: 'RS',
  RU: 'RU',
  RW: 'RW',
  SA: 'SA',
  SB: 'SB',
  SC: 'SC',
  SD: 'SD',
  SE: 'SE',
  SG: 'SG',
  SH: 'SH',
  SI: 'SI',
  SJ: 'SJ',
  SK: 'SK',
  SL: 'SL',
  SM: 'SM',
  SN: 'SN',
  SO: 'SO',
  SR: 'SR',
  SS: 'SS',
  ST: 'ST',
  SV: 'SV',
  SX: 'SX',
  SY: 'SY',
  SZ: 'SZ',
  TC: 'TC',
  TD: 'TD',
  TF: 'TF',
  TG: 'TG',
  TH: 'TH',
  TJ: 'TJ',
  TK: 'TK',
  TL: 'TL',
  TM: 'TM',
  TN: 'TN',
  TO: 'TO',
  TR: 'TR',
  TT: 'TT',
  TV: 'TV',
  TW: 'TW',
  TZ: 'TZ',
  UA: 'UA',
  UG: 'UG',
  UM: 'UM',
  US: 'US',
  UY: 'UY',
  UZ: 'UZ',
  VA: 'VA',
  VC: 'VC',
  VE: 'VE',
  VG: 'VG',
  VI: 'VI',
  VN: 'VN',
  VU: 'VU',
  WF: 'WF',
  XK: 'XK',
  WS: 'WS',
  YE: 'YE',
  YT: 'YT',
  ZA: 'ZA',
  ZM: 'ZM',
  ZW: 'ZW'
};

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


export const Status: {
  PENDING: 'PENDING',
  REJECTED: 'REJECTED',
  ACCEPTED: 'ACCEPTED'
};

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


export const documentType: {
  PASSPORT: 'PASSPORT',
  ID: 'ID',
  DRIVING_LICENSE: 'DRIVING_LICENSE'
};

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


export const INVITE_STATUS: {
  PENDING: 'PENDING',
  REJECTED: 'REJECTED',
  ACCEPTED: 'ACCEPTED',
  CREATED: 'CREATED'
};

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


export const AdminRole: {
  SUPER_ADMIN: 'SUPER_ADMIN',
  ADMIN: 'ADMIN',
  CUSTOMER_SERVICE: 'CUSTOMER_SERVICE',
  EDITOR: 'EDITOR',
  MARKETING: 'MARKETING',
  NULL: 'NULL'
};

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


export const NotificationStatus: {
  SEEN: 'SEEN',
  NOTSEEN: 'NOTSEEN'
};

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

}

export type CountryCode = $Enums.CountryCode

export const CountryCode: typeof $Enums.CountryCode

export type Status = $Enums.Status

export const Status: typeof $Enums.Status

export type documentType = $Enums.documentType

export const documentType: typeof $Enums.documentType

export type INVITE_STATUS = $Enums.INVITE_STATUS

export const INVITE_STATUS: typeof $Enums.INVITE_STATUS

export type AdminRole = $Enums.AdminRole

export const AdminRole: typeof $Enums.AdminRole

export type NotificationStatus = $Enums.NotificationStatus

export const NotificationStatus: typeof $Enums.NotificationStatus

/**
 * ##  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): void;

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

  /**
   * `prisma.expert`: Exposes CRUD operations for the **Expert** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Experts
    * const experts = await prisma.expert.findMany()
    * ```
    */
  get expert(): Prisma.ExpertDelegate<ExtArgs>;

  /**
   * `prisma.id_verification`: Exposes CRUD operations for the **id_verification** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Id_verifications
    * const id_verifications = await prisma.id_verification.findMany()
    * ```
    */
  get id_verification(): Prisma.id_verificationDelegate<ExtArgs>;

  /**
   * `prisma.email_verification_token`: Exposes CRUD operations for the **email_verification_token** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Email_verification_tokens
    * const email_verification_tokens = await prisma.email_verification_token.findMany()
    * ```
    */
  get email_verification_token(): Prisma.email_verification_tokenDelegate<ExtArgs>;

  /**
   * `prisma.question`: Exposes CRUD operations for the **Question** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Questions
    * const questions = await prisma.question.findMany()
    * ```
    */
  get question(): Prisma.QuestionDelegate<ExtArgs>;

  /**
   * `prisma.reply`: Exposes CRUD operations for the **Reply** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Replies
    * const replies = await prisma.reply.findMany()
    * ```
    */
  get reply(): Prisma.ReplyDelegate<ExtArgs>;

  /**
   * `prisma.stripeAccount`: Exposes CRUD operations for the **StripeAccount** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more StripeAccounts
    * const stripeAccounts = await prisma.stripeAccount.findMany()
    * ```
    */
  get stripeAccount(): Prisma.StripeAccountDelegate<ExtArgs>;

  /**
   * `prisma.key`: Exposes CRUD operations for the **Key** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Keys
    * const keys = await prisma.key.findMany()
    * ```
    */
  get key(): Prisma.KeyDelegate<ExtArgs>;

  /**
   * `prisma.experience`: Exposes CRUD operations for the **Experience** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Experiences
    * const experiences = await prisma.experience.findMany()
    * ```
    */
  get experience(): Prisma.ExperienceDelegate<ExtArgs>;

  /**
   * `prisma.education`: Exposes CRUD operations for the **Education** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Educations
    * const educations = await prisma.education.findMany()
    * ```
    */
  get education(): Prisma.EducationDelegate<ExtArgs>;

  /**
   * `prisma.expertise`: Exposes CRUD operations for the **Expertise** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Expertise
    * const expertise = await prisma.expertise.findMany()
    * ```
    */
  get expertise(): Prisma.ExpertiseDelegate<ExtArgs>;

  /**
   * `prisma.language`: Exposes CRUD operations for the **Language** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Languages
    * const languages = await prisma.language.findMany()
    * ```
    */
  get language(): Prisma.LanguageDelegate<ExtArgs>;

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

  /**
   * `prisma.availability`: Exposes CRUD operations for the **Availability** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Availabilities
    * const availabilities = await prisma.availability.findMany()
    * ```
    */
  get availability(): Prisma.AvailabilityDelegate<ExtArgs>;

  /**
   * `prisma.slot`: Exposes CRUD operations for the **Slot** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Slots
    * const slots = await prisma.slot.findMany()
    * ```
    */
  get slot(): Prisma.SlotDelegate<ExtArgs>;

  /**
   * `prisma.exception`: Exposes CRUD operations for the **Exception** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Exceptions
    * const exceptions = await prisma.exception.findMany()
    * ```
    */
  get exception(): Prisma.ExceptionDelegate<ExtArgs>;

  /**
   * `prisma.chat`: Exposes CRUD operations for the **Chat** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Chats
    * const chats = await prisma.chat.findMany()
    * ```
    */
  get chat(): Prisma.ChatDelegate<ExtArgs>;

  /**
   * `prisma.chatMessage`: Exposes CRUD operations for the **ChatMessage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChatMessages
    * const chatMessages = await prisma.chatMessage.findMany()
    * ```
    */
  get chatMessage(): Prisma.ChatMessageDelegate<ExtArgs>;

  /**
   * `prisma.clientReview`: Exposes CRUD operations for the **ClientReview** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ClientReviews
    * const clientReviews = await prisma.clientReview.findMany()
    * ```
    */
  get clientReview(): Prisma.ClientReviewDelegate<ExtArgs>;

  /**
   * `prisma.expertReview`: Exposes CRUD operations for the **ExpertReview** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExpertReviews
    * const expertReviews = await prisma.expertReview.findMany()
    * ```
    */
  get expertReview(): Prisma.ExpertReviewDelegate<ExtArgs>;

  /**
   * `prisma.admin_invite_experts`: Exposes CRUD operations for the **admin_invite_experts** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_invite_experts
    * const admin_invite_experts = await prisma.admin_invite_experts.findMany()
    * ```
    */
  get admin_invite_experts(): Prisma.admin_invite_expertsDelegate<ExtArgs>;

  /**
   * `prisma.admin_mbc_cms`: Exposes CRUD operations for the **admin_mbc_cms** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_mbc_cms
    * const admin_mbc_cms = await prisma.admin_mbc_cms.findMany()
    * ```
    */
  get admin_mbc_cms(): Prisma.admin_mbc_cmsDelegate<ExtArgs>;

  /**
   * `prisma.admin_mbc_faqs`: Exposes CRUD operations for the **admin_mbc_faqs** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_mbc_faqs
    * const admin_mbc_faqs = await prisma.admin_mbc_faqs.findMany()
    * ```
    */
  get admin_mbc_faqs(): Prisma.admin_mbc_faqsDelegate<ExtArgs>;

  /**
   * `prisma.admin_newsletter`: Exposes CRUD operations for the **admin_newsletter** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_newsletters
    * const admin_newsletters = await prisma.admin_newsletter.findMany()
    * ```
    */
  get admin_newsletter(): Prisma.admin_newsletterDelegate<ExtArgs>;

  /**
   * `prisma.admin_user`: Exposes CRUD operations for the **admin_user** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_users
    * const admin_users = await prisma.admin_user.findMany()
    * ```
    */
  get admin_user(): Prisma.admin_userDelegate<ExtArgs>;

  /**
   * `prisma.faqQuestion`: Exposes CRUD operations for the **faqQuestion** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FaqQuestions
    * const faqQuestions = await prisma.faqQuestion.findMany()
    * ```
    */
  get faqQuestion(): Prisma.faqQuestionDelegate<ExtArgs>;

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

  /**
   * `prisma.admin_editing`: Exposes CRUD operations for the **admin_editing** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_editings
    * const admin_editings = await prisma.admin_editing.findMany()
    * ```
    */
  get admin_editing(): Prisma.admin_editingDelegate<ExtArgs>;

  /**
   * `prisma.admin_notification`: Exposes CRUD operations for the **admin_notification** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_notifications
    * const admin_notifications = await prisma.admin_notification.findMany()
    * ```
    */
  get admin_notification(): Prisma.admin_notificationDelegate<ExtArgs>;

  /**
   * `prisma.admin_notification_status`: Exposes CRUD operations for the **admin_notification_status** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_notification_statuses
    * const admin_notification_statuses = await prisma.admin_notification_status.findMany()
    * ```
    */
  get admin_notification_status(): Prisma.admin_notification_statusDelegate<ExtArgs>;

  /**
   * `prisma.expertApplicationAnswer`: Exposes CRUD operations for the **expertApplicationAnswer** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExpertApplicationAnswers
    * const expertApplicationAnswers = await prisma.expertApplicationAnswer.findMany()
    * ```
    */
  get expertApplicationAnswer(): Prisma.expertApplicationAnswerDelegate<ExtArgs>;

  /**
   * `prisma.admin_expert_application`: Exposes CRUD operations for the **admin_expert_application** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Admin_expert_applications
    * const admin_expert_applications = await prisma.admin_expert_application.findMany()
    * ```
    */
  get admin_expert_application(): Prisma.admin_expert_applicationDelegate<ExtArgs>;

  /**
   * `prisma.expertApplicationQuestion`: Exposes CRUD operations for the **expertApplicationQuestion** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExpertApplicationQuestions
    * const expertApplicationQuestions = await prisma.expertApplicationQuestion.findMany()
    * ```
    */
  get expertApplicationQuestion(): Prisma.expertApplicationQuestionDelegate<ExtArgs>;
}

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
  export import NotFoundError = runtime.NotFoundError

  /**
   * 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: 5.20.0
   * Query Engine version: 06fc58a368dc7be9fbbbe894adf8d445d208c284
   */
  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 ? K : 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',
    Expert: 'Expert',
    id_verification: 'id_verification',
    email_verification_token: 'email_verification_token',
    Question: 'Question',
    Reply: 'Reply',
    StripeAccount: 'StripeAccount',
    Key: 'Key',
    Experience: 'Experience',
    Education: 'Education',
    Expertise: 'Expertise',
    Language: 'Language',
    Appointment: 'Appointment',
    Availability: 'Availability',
    Slot: 'Slot',
    Exception: 'Exception',
    Chat: 'Chat',
    ChatMessage: 'ChatMessage',
    ClientReview: 'ClientReview',
    ExpertReview: 'ExpertReview',
    admin_invite_experts: 'admin_invite_experts',
    admin_mbc_cms: 'admin_mbc_cms',
    admin_mbc_faqs: 'admin_mbc_faqs',
    admin_newsletter: 'admin_newsletter',
    admin_user: 'admin_user',
    faqQuestion: 'faqQuestion',
    session: 'session',
    admin_editing: 'admin_editing',
    admin_notification: 'admin_notification',
    admin_notification_status: 'admin_notification_status',
    expertApplicationAnswer: 'expertApplicationAnswer',
    admin_expert_application: 'admin_expert_application',
    expertApplicationQuestion: 'expertApplicationQuestion'
  };

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


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "user" | "expert" | "id_verification" | "email_verification_token" | "question" | "reply" | "stripeAccount" | "key" | "experience" | "education" | "expertise" | "language" | "appointment" | "availability" | "slot" | "exception" | "chat" | "chatMessage" | "clientReview" | "expertReview" | "admin_invite_experts" | "admin_mbc_cms" | "admin_mbc_faqs" | "admin_newsletter" | "admin_user" | "faqQuestion" | "session" | "admin_editing" | "admin_notification" | "admin_notification_status" | "expertApplicationAnswer" | "admin_expert_application" | "expertApplicationQuestion"
      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
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          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
          }
        }
      }
      Expert: {
        payload: Prisma.$ExpertPayload<ExtArgs>
        fields: Prisma.ExpertFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExpertFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExpertFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          findFirst: {
            args: Prisma.ExpertFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExpertFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          findMany: {
            args: Prisma.ExpertFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>[]
          }
          create: {
            args: Prisma.ExpertCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          createMany: {
            args: Prisma.ExpertCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExpertCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>[]
          }
          delete: {
            args: Prisma.ExpertDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          update: {
            args: Prisma.ExpertUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          deleteMany: {
            args: Prisma.ExpertDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExpertUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExpertUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertPayload>
          }
          aggregate: {
            args: Prisma.ExpertAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExpert>
          }
          groupBy: {
            args: Prisma.ExpertGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExpertGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExpertCountArgs<ExtArgs>
            result: $Utils.Optional<ExpertCountAggregateOutputType> | number
          }
        }
      }
      id_verification: {
        payload: Prisma.$id_verificationPayload<ExtArgs>
        fields: Prisma.id_verificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.id_verificationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.id_verificationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          findFirst: {
            args: Prisma.id_verificationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.id_verificationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          findMany: {
            args: Prisma.id_verificationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>[]
          }
          create: {
            args: Prisma.id_verificationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          createMany: {
            args: Prisma.id_verificationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.id_verificationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>[]
          }
          delete: {
            args: Prisma.id_verificationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          update: {
            args: Prisma.id_verificationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          deleteMany: {
            args: Prisma.id_verificationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.id_verificationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.id_verificationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$id_verificationPayload>
          }
          aggregate: {
            args: Prisma.Id_verificationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateId_verification>
          }
          groupBy: {
            args: Prisma.id_verificationGroupByArgs<ExtArgs>
            result: $Utils.Optional<Id_verificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.id_verificationCountArgs<ExtArgs>
            result: $Utils.Optional<Id_verificationCountAggregateOutputType> | number
          }
        }
      }
      email_verification_token: {
        payload: Prisma.$email_verification_tokenPayload<ExtArgs>
        fields: Prisma.email_verification_tokenFieldRefs
        operations: {
          findUnique: {
            args: Prisma.email_verification_tokenFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.email_verification_tokenFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          findFirst: {
            args: Prisma.email_verification_tokenFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.email_verification_tokenFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          findMany: {
            args: Prisma.email_verification_tokenFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>[]
          }
          create: {
            args: Prisma.email_verification_tokenCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          createMany: {
            args: Prisma.email_verification_tokenCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.email_verification_tokenCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>[]
          }
          delete: {
            args: Prisma.email_verification_tokenDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          update: {
            args: Prisma.email_verification_tokenUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          deleteMany: {
            args: Prisma.email_verification_tokenDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.email_verification_tokenUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.email_verification_tokenUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$email_verification_tokenPayload>
          }
          aggregate: {
            args: Prisma.Email_verification_tokenAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEmail_verification_token>
          }
          groupBy: {
            args: Prisma.email_verification_tokenGroupByArgs<ExtArgs>
            result: $Utils.Optional<Email_verification_tokenGroupByOutputType>[]
          }
          count: {
            args: Prisma.email_verification_tokenCountArgs<ExtArgs>
            result: $Utils.Optional<Email_verification_tokenCountAggregateOutputType> | number
          }
        }
      }
      Question: {
        payload: Prisma.$QuestionPayload<ExtArgs>
        fields: Prisma.QuestionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.QuestionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.QuestionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          findFirst: {
            args: Prisma.QuestionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.QuestionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          findMany: {
            args: Prisma.QuestionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>[]
          }
          create: {
            args: Prisma.QuestionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          createMany: {
            args: Prisma.QuestionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.QuestionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>[]
          }
          delete: {
            args: Prisma.QuestionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          update: {
            args: Prisma.QuestionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          deleteMany: {
            args: Prisma.QuestionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.QuestionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.QuestionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
          }
          aggregate: {
            args: Prisma.QuestionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateQuestion>
          }
          groupBy: {
            args: Prisma.QuestionGroupByArgs<ExtArgs>
            result: $Utils.Optional<QuestionGroupByOutputType>[]
          }
          count: {
            args: Prisma.QuestionCountArgs<ExtArgs>
            result: $Utils.Optional<QuestionCountAggregateOutputType> | number
          }
        }
      }
      Reply: {
        payload: Prisma.$ReplyPayload<ExtArgs>
        fields: Prisma.ReplyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ReplyFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ReplyFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          findFirst: {
            args: Prisma.ReplyFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ReplyFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          findMany: {
            args: Prisma.ReplyFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>[]
          }
          create: {
            args: Prisma.ReplyCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          createMany: {
            args: Prisma.ReplyCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ReplyCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>[]
          }
          delete: {
            args: Prisma.ReplyDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          update: {
            args: Prisma.ReplyUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          deleteMany: {
            args: Prisma.ReplyDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ReplyUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ReplyUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReplyPayload>
          }
          aggregate: {
            args: Prisma.ReplyAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateReply>
          }
          groupBy: {
            args: Prisma.ReplyGroupByArgs<ExtArgs>
            result: $Utils.Optional<ReplyGroupByOutputType>[]
          }
          count: {
            args: Prisma.ReplyCountArgs<ExtArgs>
            result: $Utils.Optional<ReplyCountAggregateOutputType> | number
          }
        }
      }
      StripeAccount: {
        payload: Prisma.$StripeAccountPayload<ExtArgs>
        fields: Prisma.StripeAccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.StripeAccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.StripeAccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          findFirst: {
            args: Prisma.StripeAccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.StripeAccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          findMany: {
            args: Prisma.StripeAccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>[]
          }
          create: {
            args: Prisma.StripeAccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          createMany: {
            args: Prisma.StripeAccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.StripeAccountCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>[]
          }
          delete: {
            args: Prisma.StripeAccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          update: {
            args: Prisma.StripeAccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          deleteMany: {
            args: Prisma.StripeAccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.StripeAccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.StripeAccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StripeAccountPayload>
          }
          aggregate: {
            args: Prisma.StripeAccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateStripeAccount>
          }
          groupBy: {
            args: Prisma.StripeAccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<StripeAccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.StripeAccountCountArgs<ExtArgs>
            result: $Utils.Optional<StripeAccountCountAggregateOutputType> | number
          }
        }
      }
      Key: {
        payload: Prisma.$KeyPayload<ExtArgs>
        fields: Prisma.KeyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.KeyFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.KeyFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          findFirst: {
            args: Prisma.KeyFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.KeyFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          findMany: {
            args: Prisma.KeyFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>[]
          }
          create: {
            args: Prisma.KeyCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          createMany: {
            args: Prisma.KeyCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.KeyCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>[]
          }
          delete: {
            args: Prisma.KeyDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          update: {
            args: Prisma.KeyUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          deleteMany: {
            args: Prisma.KeyDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.KeyUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.KeyUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KeyPayload>
          }
          aggregate: {
            args: Prisma.KeyAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateKey>
          }
          groupBy: {
            args: Prisma.KeyGroupByArgs<ExtArgs>
            result: $Utils.Optional<KeyGroupByOutputType>[]
          }
          count: {
            args: Prisma.KeyCountArgs<ExtArgs>
            result: $Utils.Optional<KeyCountAggregateOutputType> | number
          }
        }
      }
      Experience: {
        payload: Prisma.$ExperiencePayload<ExtArgs>
        fields: Prisma.ExperienceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExperienceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExperienceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          findFirst: {
            args: Prisma.ExperienceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExperienceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          findMany: {
            args: Prisma.ExperienceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>[]
          }
          create: {
            args: Prisma.ExperienceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          createMany: {
            args: Prisma.ExperienceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExperienceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>[]
          }
          delete: {
            args: Prisma.ExperienceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          update: {
            args: Prisma.ExperienceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          deleteMany: {
            args: Prisma.ExperienceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExperienceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExperienceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExperiencePayload>
          }
          aggregate: {
            args: Prisma.ExperienceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExperience>
          }
          groupBy: {
            args: Prisma.ExperienceGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExperienceGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExperienceCountArgs<ExtArgs>
            result: $Utils.Optional<ExperienceCountAggregateOutputType> | number
          }
        }
      }
      Education: {
        payload: Prisma.$EducationPayload<ExtArgs>
        fields: Prisma.EducationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EducationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EducationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          findFirst: {
            args: Prisma.EducationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EducationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          findMany: {
            args: Prisma.EducationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>[]
          }
          create: {
            args: Prisma.EducationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          createMany: {
            args: Prisma.EducationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.EducationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>[]
          }
          delete: {
            args: Prisma.EducationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          update: {
            args: Prisma.EducationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          deleteMany: {
            args: Prisma.EducationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EducationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EducationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EducationPayload>
          }
          aggregate: {
            args: Prisma.EducationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEducation>
          }
          groupBy: {
            args: Prisma.EducationGroupByArgs<ExtArgs>
            result: $Utils.Optional<EducationGroupByOutputType>[]
          }
          count: {
            args: Prisma.EducationCountArgs<ExtArgs>
            result: $Utils.Optional<EducationCountAggregateOutputType> | number
          }
        }
      }
      Expertise: {
        payload: Prisma.$ExpertisePayload<ExtArgs>
        fields: Prisma.ExpertiseFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExpertiseFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExpertiseFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          findFirst: {
            args: Prisma.ExpertiseFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExpertiseFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          findMany: {
            args: Prisma.ExpertiseFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>[]
          }
          create: {
            args: Prisma.ExpertiseCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          createMany: {
            args: Prisma.ExpertiseCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExpertiseCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>[]
          }
          delete: {
            args: Prisma.ExpertiseDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          update: {
            args: Prisma.ExpertiseUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          deleteMany: {
            args: Prisma.ExpertiseDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExpertiseUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExpertiseUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertisePayload>
          }
          aggregate: {
            args: Prisma.ExpertiseAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExpertise>
          }
          groupBy: {
            args: Prisma.ExpertiseGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExpertiseGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExpertiseCountArgs<ExtArgs>
            result: $Utils.Optional<ExpertiseCountAggregateOutputType> | number
          }
        }
      }
      Language: {
        payload: Prisma.$LanguagePayload<ExtArgs>
        fields: Prisma.LanguageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LanguageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LanguageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          findFirst: {
            args: Prisma.LanguageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LanguageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          findMany: {
            args: Prisma.LanguageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>[]
          }
          create: {
            args: Prisma.LanguageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          createMany: {
            args: Prisma.LanguageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LanguageCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>[]
          }
          delete: {
            args: Prisma.LanguageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          update: {
            args: Prisma.LanguageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          deleteMany: {
            args: Prisma.LanguageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LanguageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LanguageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LanguagePayload>
          }
          aggregate: {
            args: Prisma.LanguageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLanguage>
          }
          groupBy: {
            args: Prisma.LanguageGroupByArgs<ExtArgs>
            result: $Utils.Optional<LanguageGroupByOutputType>[]
          }
          count: {
            args: Prisma.LanguageCountArgs<ExtArgs>
            result: $Utils.Optional<LanguageCountAggregateOutputType> | 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
          }
          createManyAndReturn: {
            args: Prisma.AppointmentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>[]
          }
          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
          }
        }
      }
      Availability: {
        payload: Prisma.$AvailabilityPayload<ExtArgs>
        fields: Prisma.AvailabilityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AvailabilityFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AvailabilityFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          findFirst: {
            args: Prisma.AvailabilityFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AvailabilityFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          findMany: {
            args: Prisma.AvailabilityFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>[]
          }
          create: {
            args: Prisma.AvailabilityCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          createMany: {
            args: Prisma.AvailabilityCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AvailabilityCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>[]
          }
          delete: {
            args: Prisma.AvailabilityDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          update: {
            args: Prisma.AvailabilityUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          deleteMany: {
            args: Prisma.AvailabilityDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AvailabilityUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AvailabilityUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AvailabilityPayload>
          }
          aggregate: {
            args: Prisma.AvailabilityAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAvailability>
          }
          groupBy: {
            args: Prisma.AvailabilityGroupByArgs<ExtArgs>
            result: $Utils.Optional<AvailabilityGroupByOutputType>[]
          }
          count: {
            args: Prisma.AvailabilityCountArgs<ExtArgs>
            result: $Utils.Optional<AvailabilityCountAggregateOutputType> | number
          }
        }
      }
      Slot: {
        payload: Prisma.$SlotPayload<ExtArgs>
        fields: Prisma.SlotFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SlotFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SlotFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          findFirst: {
            args: Prisma.SlotFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SlotFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          findMany: {
            args: Prisma.SlotFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>[]
          }
          create: {
            args: Prisma.SlotCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          createMany: {
            args: Prisma.SlotCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SlotCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>[]
          }
          delete: {
            args: Prisma.SlotDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          update: {
            args: Prisma.SlotUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          deleteMany: {
            args: Prisma.SlotDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SlotUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SlotUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SlotPayload>
          }
          aggregate: {
            args: Prisma.SlotAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSlot>
          }
          groupBy: {
            args: Prisma.SlotGroupByArgs<ExtArgs>
            result: $Utils.Optional<SlotGroupByOutputType>[]
          }
          count: {
            args: Prisma.SlotCountArgs<ExtArgs>
            result: $Utils.Optional<SlotCountAggregateOutputType> | number
          }
        }
      }
      Exception: {
        payload: Prisma.$ExceptionPayload<ExtArgs>
        fields: Prisma.ExceptionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExceptionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExceptionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          findFirst: {
            args: Prisma.ExceptionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExceptionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          findMany: {
            args: Prisma.ExceptionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>[]
          }
          create: {
            args: Prisma.ExceptionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          createMany: {
            args: Prisma.ExceptionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExceptionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>[]
          }
          delete: {
            args: Prisma.ExceptionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          update: {
            args: Prisma.ExceptionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          deleteMany: {
            args: Prisma.ExceptionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExceptionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExceptionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExceptionPayload>
          }
          aggregate: {
            args: Prisma.ExceptionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateException>
          }
          groupBy: {
            args: Prisma.ExceptionGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExceptionGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExceptionCountArgs<ExtArgs>
            result: $Utils.Optional<ExceptionCountAggregateOutputType> | number
          }
        }
      }
      Chat: {
        payload: Prisma.$ChatPayload<ExtArgs>
        fields: Prisma.ChatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChatFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChatFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          findFirst: {
            args: Prisma.ChatFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChatFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          findMany: {
            args: Prisma.ChatFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>[]
          }
          create: {
            args: Prisma.ChatCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          createMany: {
            args: Prisma.ChatCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ChatCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>[]
          }
          delete: {
            args: Prisma.ChatDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          update: {
            args: Prisma.ChatUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          deleteMany: {
            args: Prisma.ChatDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ChatUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ChatUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          aggregate: {
            args: Prisma.ChatAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateChat>
          }
          groupBy: {
            args: Prisma.ChatGroupByArgs<ExtArgs>
            result: $Utils.Optional<ChatGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChatCountArgs<ExtArgs>
            result: $Utils.Optional<ChatCountAggregateOutputType> | number
          }
        }
      }
      ChatMessage: {
        payload: Prisma.$ChatMessagePayload<ExtArgs>
        fields: Prisma.ChatMessageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChatMessageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChatMessageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          findFirst: {
            args: Prisma.ChatMessageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChatMessageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          findMany: {
            args: Prisma.ChatMessageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>[]
          }
          create: {
            args: Prisma.ChatMessageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          createMany: {
            args: Prisma.ChatMessageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ChatMessageCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>[]
          }
          delete: {
            args: Prisma.ChatMessageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          update: {
            args: Prisma.ChatMessageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          deleteMany: {
            args: Prisma.ChatMessageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ChatMessageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ChatMessageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatMessagePayload>
          }
          aggregate: {
            args: Prisma.ChatMessageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateChatMessage>
          }
          groupBy: {
            args: Prisma.ChatMessageGroupByArgs<ExtArgs>
            result: $Utils.Optional<ChatMessageGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChatMessageCountArgs<ExtArgs>
            result: $Utils.Optional<ChatMessageCountAggregateOutputType> | number
          }
        }
      }
      ClientReview: {
        payload: Prisma.$ClientReviewPayload<ExtArgs>
        fields: Prisma.ClientReviewFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ClientReviewFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ClientReviewFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          findFirst: {
            args: Prisma.ClientReviewFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ClientReviewFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          findMany: {
            args: Prisma.ClientReviewFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>[]
          }
          create: {
            args: Prisma.ClientReviewCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          createMany: {
            args: Prisma.ClientReviewCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ClientReviewCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>[]
          }
          delete: {
            args: Prisma.ClientReviewDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          update: {
            args: Prisma.ClientReviewUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          deleteMany: {
            args: Prisma.ClientReviewDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ClientReviewUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ClientReviewUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClientReviewPayload>
          }
          aggregate: {
            args: Prisma.ClientReviewAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClientReview>
          }
          groupBy: {
            args: Prisma.ClientReviewGroupByArgs<ExtArgs>
            result: $Utils.Optional<ClientReviewGroupByOutputType>[]
          }
          count: {
            args: Prisma.ClientReviewCountArgs<ExtArgs>
            result: $Utils.Optional<ClientReviewCountAggregateOutputType> | number
          }
        }
      }
      ExpertReview: {
        payload: Prisma.$ExpertReviewPayload<ExtArgs>
        fields: Prisma.ExpertReviewFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExpertReviewFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExpertReviewFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          findFirst: {
            args: Prisma.ExpertReviewFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExpertReviewFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          findMany: {
            args: Prisma.ExpertReviewFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>[]
          }
          create: {
            args: Prisma.ExpertReviewCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          createMany: {
            args: Prisma.ExpertReviewCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExpertReviewCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>[]
          }
          delete: {
            args: Prisma.ExpertReviewDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          update: {
            args: Prisma.ExpertReviewUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          deleteMany: {
            args: Prisma.ExpertReviewDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExpertReviewUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExpertReviewUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExpertReviewPayload>
          }
          aggregate: {
            args: Prisma.ExpertReviewAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExpertReview>
          }
          groupBy: {
            args: Prisma.ExpertReviewGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExpertReviewGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExpertReviewCountArgs<ExtArgs>
            result: $Utils.Optional<ExpertReviewCountAggregateOutputType> | number
          }
        }
      }
      admin_invite_experts: {
        payload: Prisma.$admin_invite_expertsPayload<ExtArgs>
        fields: Prisma.admin_invite_expertsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_invite_expertsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_invite_expertsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          findFirst: {
            args: Prisma.admin_invite_expertsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_invite_expertsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          findMany: {
            args: Prisma.admin_invite_expertsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>[]
          }
          create: {
            args: Prisma.admin_invite_expertsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          createMany: {
            args: Prisma.admin_invite_expertsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_invite_expertsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>[]
          }
          delete: {
            args: Prisma.admin_invite_expertsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          update: {
            args: Prisma.admin_invite_expertsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          deleteMany: {
            args: Prisma.admin_invite_expertsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_invite_expertsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_invite_expertsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_invite_expertsPayload>
          }
          aggregate: {
            args: Prisma.Admin_invite_expertsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_invite_experts>
          }
          groupBy: {
            args: Prisma.admin_invite_expertsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_invite_expertsGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_invite_expertsCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_invite_expertsCountAggregateOutputType> | number
          }
        }
      }
      admin_mbc_cms: {
        payload: Prisma.$admin_mbc_cmsPayload<ExtArgs>
        fields: Prisma.admin_mbc_cmsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_mbc_cmsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_mbc_cmsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          findFirst: {
            args: Prisma.admin_mbc_cmsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_mbc_cmsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          findMany: {
            args: Prisma.admin_mbc_cmsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>[]
          }
          create: {
            args: Prisma.admin_mbc_cmsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          createMany: {
            args: Prisma.admin_mbc_cmsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_mbc_cmsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>[]
          }
          delete: {
            args: Prisma.admin_mbc_cmsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          update: {
            args: Prisma.admin_mbc_cmsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          deleteMany: {
            args: Prisma.admin_mbc_cmsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_mbc_cmsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_mbc_cmsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_cmsPayload>
          }
          aggregate: {
            args: Prisma.Admin_mbc_cmsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_mbc_cms>
          }
          groupBy: {
            args: Prisma.admin_mbc_cmsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_mbc_cmsGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_mbc_cmsCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_mbc_cmsCountAggregateOutputType> | number
          }
        }
      }
      admin_mbc_faqs: {
        payload: Prisma.$admin_mbc_faqsPayload<ExtArgs>
        fields: Prisma.admin_mbc_faqsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_mbc_faqsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_mbc_faqsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          findFirst: {
            args: Prisma.admin_mbc_faqsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_mbc_faqsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          findMany: {
            args: Prisma.admin_mbc_faqsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>[]
          }
          create: {
            args: Prisma.admin_mbc_faqsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          createMany: {
            args: Prisma.admin_mbc_faqsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_mbc_faqsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>[]
          }
          delete: {
            args: Prisma.admin_mbc_faqsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          update: {
            args: Prisma.admin_mbc_faqsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          deleteMany: {
            args: Prisma.admin_mbc_faqsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_mbc_faqsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_mbc_faqsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_mbc_faqsPayload>
          }
          aggregate: {
            args: Prisma.Admin_mbc_faqsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_mbc_faqs>
          }
          groupBy: {
            args: Prisma.admin_mbc_faqsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_mbc_faqsGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_mbc_faqsCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_mbc_faqsCountAggregateOutputType> | number
          }
        }
      }
      admin_newsletter: {
        payload: Prisma.$admin_newsletterPayload<ExtArgs>
        fields: Prisma.admin_newsletterFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_newsletterFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_newsletterFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          findFirst: {
            args: Prisma.admin_newsletterFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_newsletterFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          findMany: {
            args: Prisma.admin_newsletterFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>[]
          }
          create: {
            args: Prisma.admin_newsletterCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          createMany: {
            args: Prisma.admin_newsletterCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_newsletterCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>[]
          }
          delete: {
            args: Prisma.admin_newsletterDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          update: {
            args: Prisma.admin_newsletterUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          deleteMany: {
            args: Prisma.admin_newsletterDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_newsletterUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_newsletterUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_newsletterPayload>
          }
          aggregate: {
            args: Prisma.Admin_newsletterAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_newsletter>
          }
          groupBy: {
            args: Prisma.admin_newsletterGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_newsletterGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_newsletterCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_newsletterCountAggregateOutputType> | number
          }
        }
      }
      admin_user: {
        payload: Prisma.$admin_userPayload<ExtArgs>
        fields: Prisma.admin_userFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_userFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_userFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          findFirst: {
            args: Prisma.admin_userFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_userFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          findMany: {
            args: Prisma.admin_userFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>[]
          }
          create: {
            args: Prisma.admin_userCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          createMany: {
            args: Prisma.admin_userCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_userCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>[]
          }
          delete: {
            args: Prisma.admin_userDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          update: {
            args: Prisma.admin_userUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          deleteMany: {
            args: Prisma.admin_userDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_userUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_userUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_userPayload>
          }
          aggregate: {
            args: Prisma.Admin_userAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_user>
          }
          groupBy: {
            args: Prisma.admin_userGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_userGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_userCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_userCountAggregateOutputType> | number
          }
        }
      }
      faqQuestion: {
        payload: Prisma.$faqQuestionPayload<ExtArgs>
        fields: Prisma.faqQuestionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.faqQuestionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.faqQuestionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          findFirst: {
            args: Prisma.faqQuestionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.faqQuestionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          findMany: {
            args: Prisma.faqQuestionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>[]
          }
          create: {
            args: Prisma.faqQuestionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          createMany: {
            args: Prisma.faqQuestionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.faqQuestionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>[]
          }
          delete: {
            args: Prisma.faqQuestionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          update: {
            args: Prisma.faqQuestionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          deleteMany: {
            args: Prisma.faqQuestionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.faqQuestionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.faqQuestionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$faqQuestionPayload>
          }
          aggregate: {
            args: Prisma.FaqQuestionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFaqQuestion>
          }
          groupBy: {
            args: Prisma.faqQuestionGroupByArgs<ExtArgs>
            result: $Utils.Optional<FaqQuestionGroupByOutputType>[]
          }
          count: {
            args: Prisma.faqQuestionCountArgs<ExtArgs>
            result: $Utils.Optional<FaqQuestionCountAggregateOutputType> | 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
          }
          createManyAndReturn: {
            args: Prisma.sessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionPayload>[]
          }
          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
          }
        }
      }
      admin_editing: {
        payload: Prisma.$admin_editingPayload<ExtArgs>
        fields: Prisma.admin_editingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_editingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_editingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          findFirst: {
            args: Prisma.admin_editingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_editingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          findMany: {
            args: Prisma.admin_editingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>[]
          }
          create: {
            args: Prisma.admin_editingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          createMany: {
            args: Prisma.admin_editingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_editingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>[]
          }
          delete: {
            args: Prisma.admin_editingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          update: {
            args: Prisma.admin_editingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          deleteMany: {
            args: Prisma.admin_editingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_editingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_editingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_editingPayload>
          }
          aggregate: {
            args: Prisma.Admin_editingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_editing>
          }
          groupBy: {
            args: Prisma.admin_editingGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_editingGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_editingCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_editingCountAggregateOutputType> | number
          }
        }
      }
      admin_notification: {
        payload: Prisma.$admin_notificationPayload<ExtArgs>
        fields: Prisma.admin_notificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_notificationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_notificationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          findFirst: {
            args: Prisma.admin_notificationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_notificationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          findMany: {
            args: Prisma.admin_notificationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>[]
          }
          create: {
            args: Prisma.admin_notificationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          createMany: {
            args: Prisma.admin_notificationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_notificationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>[]
          }
          delete: {
            args: Prisma.admin_notificationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          update: {
            args: Prisma.admin_notificationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          deleteMany: {
            args: Prisma.admin_notificationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_notificationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_notificationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notificationPayload>
          }
          aggregate: {
            args: Prisma.Admin_notificationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_notification>
          }
          groupBy: {
            args: Prisma.admin_notificationGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_notificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_notificationCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_notificationCountAggregateOutputType> | number
          }
        }
      }
      admin_notification_status: {
        payload: Prisma.$admin_notification_statusPayload<ExtArgs>
        fields: Prisma.admin_notification_statusFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_notification_statusFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_notification_statusFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          findFirst: {
            args: Prisma.admin_notification_statusFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_notification_statusFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          findMany: {
            args: Prisma.admin_notification_statusFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>[]
          }
          create: {
            args: Prisma.admin_notification_statusCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          createMany: {
            args: Prisma.admin_notification_statusCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_notification_statusCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>[]
          }
          delete: {
            args: Prisma.admin_notification_statusDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          update: {
            args: Prisma.admin_notification_statusUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          deleteMany: {
            args: Prisma.admin_notification_statusDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_notification_statusUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_notification_statusUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_notification_statusPayload>
          }
          aggregate: {
            args: Prisma.Admin_notification_statusAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_notification_status>
          }
          groupBy: {
            args: Prisma.admin_notification_statusGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_notification_statusGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_notification_statusCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_notification_statusCountAggregateOutputType> | number
          }
        }
      }
      expertApplicationAnswer: {
        payload: Prisma.$expertApplicationAnswerPayload<ExtArgs>
        fields: Prisma.expertApplicationAnswerFieldRefs
        operations: {
          findUnique: {
            args: Prisma.expertApplicationAnswerFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.expertApplicationAnswerFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          findFirst: {
            args: Prisma.expertApplicationAnswerFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.expertApplicationAnswerFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          findMany: {
            args: Prisma.expertApplicationAnswerFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>[]
          }
          create: {
            args: Prisma.expertApplicationAnswerCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          createMany: {
            args: Prisma.expertApplicationAnswerCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.expertApplicationAnswerCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>[]
          }
          delete: {
            args: Prisma.expertApplicationAnswerDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          update: {
            args: Prisma.expertApplicationAnswerUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          deleteMany: {
            args: Prisma.expertApplicationAnswerDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.expertApplicationAnswerUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.expertApplicationAnswerUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationAnswerPayload>
          }
          aggregate: {
            args: Prisma.ExpertApplicationAnswerAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExpertApplicationAnswer>
          }
          groupBy: {
            args: Prisma.expertApplicationAnswerGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExpertApplicationAnswerGroupByOutputType>[]
          }
          count: {
            args: Prisma.expertApplicationAnswerCountArgs<ExtArgs>
            result: $Utils.Optional<ExpertApplicationAnswerCountAggregateOutputType> | number
          }
        }
      }
      admin_expert_application: {
        payload: Prisma.$admin_expert_applicationPayload<ExtArgs>
        fields: Prisma.admin_expert_applicationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.admin_expert_applicationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.admin_expert_applicationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          findFirst: {
            args: Prisma.admin_expert_applicationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.admin_expert_applicationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          findMany: {
            args: Prisma.admin_expert_applicationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>[]
          }
          create: {
            args: Prisma.admin_expert_applicationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          createMany: {
            args: Prisma.admin_expert_applicationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.admin_expert_applicationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>[]
          }
          delete: {
            args: Prisma.admin_expert_applicationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          update: {
            args: Prisma.admin_expert_applicationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          deleteMany: {
            args: Prisma.admin_expert_applicationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.admin_expert_applicationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.admin_expert_applicationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$admin_expert_applicationPayload>
          }
          aggregate: {
            args: Prisma.Admin_expert_applicationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdmin_expert_application>
          }
          groupBy: {
            args: Prisma.admin_expert_applicationGroupByArgs<ExtArgs>
            result: $Utils.Optional<Admin_expert_applicationGroupByOutputType>[]
          }
          count: {
            args: Prisma.admin_expert_applicationCountArgs<ExtArgs>
            result: $Utils.Optional<Admin_expert_applicationCountAggregateOutputType> | number
          }
        }
      }
      expertApplicationQuestion: {
        payload: Prisma.$expertApplicationQuestionPayload<ExtArgs>
        fields: Prisma.expertApplicationQuestionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.expertApplicationQuestionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.expertApplicationQuestionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          findFirst: {
            args: Prisma.expertApplicationQuestionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.expertApplicationQuestionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          findMany: {
            args: Prisma.expertApplicationQuestionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>[]
          }
          create: {
            args: Prisma.expertApplicationQuestionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          createMany: {
            args: Prisma.expertApplicationQuestionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.expertApplicationQuestionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>[]
          }
          delete: {
            args: Prisma.expertApplicationQuestionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          update: {
            args: Prisma.expertApplicationQuestionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          deleteMany: {
            args: Prisma.expertApplicationQuestionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.expertApplicationQuestionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.expertApplicationQuestionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$expertApplicationQuestionPayload>
          }
          aggregate: {
            args: Prisma.ExpertApplicationQuestionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExpertApplicationQuestion>
          }
          groupBy: {
            args: Prisma.expertApplicationQuestionGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExpertApplicationQuestionGroupByOutputType>[]
          }
          count: {
            args: Prisma.expertApplicationQuestionCountArgs<ExtArgs>
            result: $Utils.Optional<ExpertApplicationQuestionCountAggregateOutputType> | 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
    }
  }


  /* 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'
    | '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 = {
    Appointment: number
    availabilities: number
    Chat: number
    messages: number
    receivedClientReviews: number
    educations: number
    experiences: number
    writtenExpertReviews: number
    expertises: number
    key: number
    languagesSpoken: number
    Questions: number
    reply: number
    admin_expert_application: number
    email_verification_token: number
    expertApplicationAnswer: number
    id_verification: number
    session: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | UserCountOutputTypeCountAppointmentArgs
    availabilities?: boolean | UserCountOutputTypeCountAvailabilitiesArgs
    Chat?: boolean | UserCountOutputTypeCountChatArgs
    messages?: boolean | UserCountOutputTypeCountMessagesArgs
    receivedClientReviews?: boolean | UserCountOutputTypeCountReceivedClientReviewsArgs
    educations?: boolean | UserCountOutputTypeCountEducationsArgs
    experiences?: boolean | UserCountOutputTypeCountExperiencesArgs
    writtenExpertReviews?: boolean | UserCountOutputTypeCountWrittenExpertReviewsArgs
    expertises?: boolean | UserCountOutputTypeCountExpertisesArgs
    key?: boolean | UserCountOutputTypeCountKeyArgs
    languagesSpoken?: boolean | UserCountOutputTypeCountLanguagesSpokenArgs
    Questions?: boolean | UserCountOutputTypeCountQuestionsArgs
    reply?: boolean | UserCountOutputTypeCountReplyArgs
    admin_expert_application?: boolean | UserCountOutputTypeCountAdmin_expert_applicationArgs
    email_verification_token?: boolean | UserCountOutputTypeCountEmail_verification_tokenArgs
    expertApplicationAnswer?: boolean | UserCountOutputTypeCountExpertApplicationAnswerArgs
    id_verification?: boolean | UserCountOutputTypeCountId_verificationArgs
    session?: boolean | UserCountOutputTypeCountSessionArgs
  }

  // 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 UserCountOutputTypeCountAppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  /**
   * Count Type ExpertCountOutputType
   */

  export type ExpertCountOutputType = {
    Appointment: number
    Availabilities: number
    Chat: number
    ChatMessage: number
    ClientReview: number
    ExpertReview: number
  }

  export type ExpertCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | ExpertCountOutputTypeCountAppointmentArgs
    Availabilities?: boolean | ExpertCountOutputTypeCountAvailabilitiesArgs
    Chat?: boolean | ExpertCountOutputTypeCountChatArgs
    ChatMessage?: boolean | ExpertCountOutputTypeCountChatMessageArgs
    ClientReview?: boolean | ExpertCountOutputTypeCountClientReviewArgs
    ExpertReview?: boolean | ExpertCountOutputTypeCountExpertReviewArgs
  }

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

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

  /**
   * ExpertCountOutputType without action
   */
  export type ExpertCountOutputTypeCountAvailabilitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AvailabilityWhereInput
  }

  /**
   * ExpertCountOutputType without action
   */
  export type ExpertCountOutputTypeCountChatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatWhereInput
  }

  /**
   * ExpertCountOutputType without action
   */
  export type ExpertCountOutputTypeCountChatMessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatMessageWhereInput
  }

  /**
   * ExpertCountOutputType without action
   */
  export type ExpertCountOutputTypeCountClientReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClientReviewWhereInput
  }

  /**
   * ExpertCountOutputType without action
   */
  export type ExpertCountOutputTypeCountExpertReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExpertReviewWhereInput
  }


  /**
   * Count Type AppointmentCountOutputType
   */

  export type AppointmentCountOutputType = {
    reply: number
  }

  export type AppointmentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    reply?: boolean | AppointmentCountOutputTypeCountReplyArgs
  }

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

  /**
   * AppointmentCountOutputType without action
   */
  export type AppointmentCountOutputTypeCountReplyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReplyWhereInput
  }


  /**
   * Count Type AvailabilityCountOutputType
   */

  export type AvailabilityCountOutputType = {
    slots: number
  }

  export type AvailabilityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    slots?: boolean | AvailabilityCountOutputTypeCountSlotsArgs
  }

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

  /**
   * AvailabilityCountOutputType without action
   */
  export type AvailabilityCountOutputTypeCountSlotsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SlotWhereInput
  }


  /**
   * Count Type SlotCountOutputType
   */

  export type SlotCountOutputType = {
    exceptions: number
  }

  export type SlotCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    exceptions?: boolean | SlotCountOutputTypeCountExceptionsArgs
  }

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

  /**
   * SlotCountOutputType without action
   */
  export type SlotCountOutputTypeCountExceptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExceptionWhereInput
  }


  /**
   * Count Type ChatCountOutputType
   */

  export type ChatCountOutputType = {
    messages: number
  }

  export type ChatCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    messages?: boolean | ChatCountOutputTypeCountMessagesArgs
  }

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

  /**
   * ChatCountOutputType without action
   */
  export type ChatCountOutputTypeCountMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatMessageWhereInput
  }


  /**
   * Count Type Admin_expert_applicationCountOutputType
   */

  export type Admin_expert_applicationCountOutputType = {
    answer: number
  }

  export type Admin_expert_applicationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    answer?: boolean | Admin_expert_applicationCountOutputTypeCountAnswerArgs
  }

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

  /**
   * Admin_expert_applicationCountOutputType without action
   */
  export type Admin_expert_applicationCountOutputTypeCountAnswerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: expertApplicationAnswerWhereInput
  }


  /**
   * Count Type ExpertApplicationQuestionCountOutputType
   */

  export type ExpertApplicationQuestionCountOutputType = {
    expertApplicationAnswer: number
  }

  export type ExpertApplicationQuestionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expertApplicationAnswer?: boolean | ExpertApplicationQuestionCountOutputTypeCountExpertApplicationAnswerArgs
  }

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

  /**
   * ExpertApplicationQuestionCountOutputType without action
   */
  export type ExpertApplicationQuestionCountOutputTypeCountExpertApplicationAnswerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: expertApplicationAnswerWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

  export type AggregateUser = {
    _count: UserCountAggregateOutputType | null
    _avg: UserAvgAggregateOutputType | null
    _sum: UserSumAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  export type UserAvgAggregateOutputType = {
    follower: number | null
    is_invited: number | null
    countryOfResidenceId: number | null
  }

  export type UserSumAggregateOutputType = {
    follower: number | null
    is_invited: number | null
    countryOfResidenceId: number | null
  }

  export type UserMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    email: string | null
    imageUrl: string | null
    imageName: string | null
    customer_id: string | null
    phone: string | null
    follower: number | null
    role: string | null
    state: string | null
    city: string | null
    zipcode: string | null
    timezone: string | null
    rate: string | null
    countryOfResidence: string | null
    biography: string | null
    linkedInURL: string | null
    instagramURL: string | null
    youtubeURL: string | null
    spotifyURL: string | null
    tiktokURL: string | null
    twitterURL: string | null
    amazonURL: string | null
    websiteURL1: string | null
    websiteURL2: string | null
    createdAt: Date | null
    refresh_token: string | null
    isExpert: boolean | null
    expertId: string | null
    provider: string | null
    is_invited: number | null
    userName: string | null
    isBanned: boolean | null
    isAdmin: boolean | null
    isSubscribed: boolean | null
    countryOfResidenceISO: $Enums.CountryCode | null
    countryOfResidenceId: number | null
    dateOfBirth: Date | null
    emailVerified: boolean | null
    idVerified: boolean | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    email: string | null
    imageUrl: string | null
    imageName: string | null
    customer_id: string | null
    phone: string | null
    follower: number | null
    role: string | null
    state: string | null
    city: string | null
    zipcode: string | null
    timezone: string | null
    rate: string | null
    countryOfResidence: string | null
    biography: string | null
    linkedInURL: string | null
    instagramURL: string | null
    youtubeURL: string | null
    spotifyURL: string | null
    tiktokURL: string | null
    twitterURL: string | null
    amazonURL: string | null
    websiteURL1: string | null
    websiteURL2: string | null
    createdAt: Date | null
    refresh_token: string | null
    isExpert: boolean | null
    expertId: string | null
    provider: string | null
    is_invited: number | null
    userName: string | null
    isBanned: boolean | null
    isAdmin: boolean | null
    isSubscribed: boolean | null
    countryOfResidenceISO: $Enums.CountryCode | null
    countryOfResidenceId: number | null
    dateOfBirth: Date | null
    emailVerified: boolean | null
    idVerified: boolean | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    email: number
    imageUrl: number
    imageName: number
    customer_id: number
    phone: number
    follower: number
    role: number
    state: number
    city: number
    zipcode: number
    timezone: number
    rate: number
    countryOfResidence: number
    biography: number
    linkedInURL: number
    instagramURL: number
    youtubeURL: number
    spotifyURL: number
    tiktokURL: number
    twitterURL: number
    amazonURL: number
    websiteURL1: number
    websiteURL2: number
    createdAt: number
    refresh_token: number
    isExpert: number
    videos: number
    expertId: number
    provider: number
    otherInfo: number
    is_invited: number
    userName: number
    isBanned: number
    isAdmin: number
    isSubscribed: number
    countryOfResidenceISO: number
    countryOfResidenceId: number
    dateOfBirth: number
    emailVerified: number
    idVerified: number
    FavoriteExpertIds: number
    _all: number
  }


  export type UserAvgAggregateInputType = {
    follower?: true
    is_invited?: true
    countryOfResidenceId?: true
  }

  export type UserSumAggregateInputType = {
    follower?: true
    is_invited?: true
    countryOfResidenceId?: true
  }

  export type UserMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    email?: true
    imageUrl?: true
    imageName?: true
    customer_id?: true
    phone?: true
    follower?: true
    role?: true
    state?: true
    city?: true
    zipcode?: true
    timezone?: true
    rate?: true
    countryOfResidence?: true
    biography?: true
    linkedInURL?: true
    instagramURL?: true
    youtubeURL?: true
    spotifyURL?: true
    tiktokURL?: true
    twitterURL?: true
    amazonURL?: true
    websiteURL1?: true
    websiteURL2?: true
    createdAt?: true
    refresh_token?: true
    isExpert?: true
    expertId?: true
    provider?: true
    is_invited?: true
    userName?: true
    isBanned?: true
    isAdmin?: true
    isSubscribed?: true
    countryOfResidenceISO?: true
    countryOfResidenceId?: true
    dateOfBirth?: true
    emailVerified?: true
    idVerified?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    email?: true
    imageUrl?: true
    imageName?: true
    customer_id?: true
    phone?: true
    follower?: true
    role?: true
    state?: true
    city?: true
    zipcode?: true
    timezone?: true
    rate?: true
    countryOfResidence?: true
    biography?: true
    linkedInURL?: true
    instagramURL?: true
    youtubeURL?: true
    spotifyURL?: true
    tiktokURL?: true
    twitterURL?: true
    amazonURL?: true
    websiteURL1?: true
    websiteURL2?: true
    createdAt?: true
    refresh_token?: true
    isExpert?: true
    expertId?: true
    provider?: true
    is_invited?: true
    userName?: true
    isBanned?: true
    isAdmin?: true
    isSubscribed?: true
    countryOfResidenceISO?: true
    countryOfResidenceId?: true
    dateOfBirth?: true
    emailVerified?: true
    idVerified?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    email?: true
    imageUrl?: true
    imageName?: true
    customer_id?: true
    phone?: true
    follower?: true
    role?: true
    state?: true
    city?: true
    zipcode?: true
    timezone?: true
    rate?: true
    countryOfResidence?: true
    biography?: true
    linkedInURL?: true
    instagramURL?: true
    youtubeURL?: true
    spotifyURL?: true
    tiktokURL?: true
    twitterURL?: true
    amazonURL?: true
    websiteURL1?: true
    websiteURL2?: true
    createdAt?: true
    refresh_token?: true
    isExpert?: true
    videos?: true
    expertId?: true
    provider?: true
    otherInfo?: true
    is_invited?: true
    userName?: true
    isBanned?: true
    isAdmin?: true
    isSubscribed?: true
    countryOfResidenceISO?: true
    countryOfResidenceId?: true
    dateOfBirth?: true
    emailVerified?: true
    idVerified?: true
    FavoriteExpertIds?: 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 average
    **/
    _avg?: UserAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UserSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserMaxAggregateInputType
  }

  export type GetUserAggregateType<T extends 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
    _avg?: UserAvgAggregateInputType
    _sum?: UserSumAggregateInputType
    _min?: UserMinAggregateInputType
    _max?: UserMaxAggregateInputType
  }

  export type UserGroupByOutputType = {
    id: string
    firstName: string | null
    lastName: string | null
    email: string
    imageUrl: string | null
    imageName: string | null
    customer_id: string | null
    phone: string | null
    follower: number | null
    role: string | null
    state: string | null
    city: string | null
    zipcode: string | null
    timezone: string | null
    rate: string | null
    countryOfResidence: string | null
    biography: string | null
    linkedInURL: string | null
    instagramURL: string | null
    youtubeURL: string | null
    spotifyURL: string | null
    tiktokURL: string | null
    twitterURL: string | null
    amazonURL: string | null
    websiteURL1: string | null
    websiteURL2: string | null
    createdAt: Date
    refresh_token: string | null
    isExpert: boolean
    videos: string[]
    expertId: string
    provider: string | null
    otherInfo: JsonValue | null
    is_invited: number | null
    userName: string | null
    isBanned: boolean
    isAdmin: boolean
    isSubscribed: boolean
    countryOfResidenceISO: $Enums.CountryCode
    countryOfResidenceId: number | null
    dateOfBirth: Date | null
    emailVerified: boolean
    idVerified: boolean
    FavoriteExpertIds: string[]
    _count: UserCountAggregateOutputType | null
    _avg: UserAvgAggregateOutputType | null
    _sum: UserSumAggregateOutputType | 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
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    imageUrl?: boolean
    imageName?: boolean
    customer_id?: boolean
    phone?: boolean
    follower?: boolean
    role?: boolean
    state?: boolean
    city?: boolean
    zipcode?: boolean
    timezone?: boolean
    rate?: boolean
    countryOfResidence?: boolean
    biography?: boolean
    linkedInURL?: boolean
    instagramURL?: boolean
    youtubeURL?: boolean
    spotifyURL?: boolean
    tiktokURL?: boolean
    twitterURL?: boolean
    amazonURL?: boolean
    websiteURL1?: boolean
    websiteURL2?: boolean
    createdAt?: boolean
    refresh_token?: boolean
    isExpert?: boolean
    videos?: boolean
    expertId?: boolean
    provider?: boolean
    otherInfo?: boolean
    is_invited?: boolean
    userName?: boolean
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: boolean
    countryOfResidenceId?: boolean
    dateOfBirth?: boolean
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: boolean
    Appointment?: boolean | User$AppointmentArgs<ExtArgs>
    availabilities?: boolean | User$availabilitiesArgs<ExtArgs>
    Chat?: boolean | User$ChatArgs<ExtArgs>
    messages?: boolean | User$messagesArgs<ExtArgs>
    receivedClientReviews?: boolean | User$receivedClientReviewsArgs<ExtArgs>
    educations?: boolean | User$educationsArgs<ExtArgs>
    experiences?: boolean | User$experiencesArgs<ExtArgs>
    Expert?: boolean | User$ExpertArgs<ExtArgs>
    writtenExpertReviews?: boolean | User$writtenExpertReviewsArgs<ExtArgs>
    expertises?: boolean | User$expertisesArgs<ExtArgs>
    key?: boolean | User$keyArgs<ExtArgs>
    languagesSpoken?: boolean | User$languagesSpokenArgs<ExtArgs>
    Questions?: boolean | User$QuestionsArgs<ExtArgs>
    reply?: boolean | User$replyArgs<ExtArgs>
    admin_expert_application?: boolean | User$admin_expert_applicationArgs<ExtArgs>
    admin_user?: boolean | User$admin_userArgs<ExtArgs>
    email_verification_token?: boolean | User$email_verification_tokenArgs<ExtArgs>
    expertApplicationAnswer?: boolean | User$expertApplicationAnswerArgs<ExtArgs>
    id_verification?: boolean | User$id_verificationArgs<ExtArgs>
    session?: boolean | User$sessionArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    imageUrl?: boolean
    imageName?: boolean
    customer_id?: boolean
    phone?: boolean
    follower?: boolean
    role?: boolean
    state?: boolean
    city?: boolean
    zipcode?: boolean
    timezone?: boolean
    rate?: boolean
    countryOfResidence?: boolean
    biography?: boolean
    linkedInURL?: boolean
    instagramURL?: boolean
    youtubeURL?: boolean
    spotifyURL?: boolean
    tiktokURL?: boolean
    twitterURL?: boolean
    amazonURL?: boolean
    websiteURL1?: boolean
    websiteURL2?: boolean
    createdAt?: boolean
    refresh_token?: boolean
    isExpert?: boolean
    videos?: boolean
    expertId?: boolean
    provider?: boolean
    otherInfo?: boolean
    is_invited?: boolean
    userName?: boolean
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: boolean
    countryOfResidenceId?: boolean
    dateOfBirth?: boolean
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    imageUrl?: boolean
    imageName?: boolean
    customer_id?: boolean
    phone?: boolean
    follower?: boolean
    role?: boolean
    state?: boolean
    city?: boolean
    zipcode?: boolean
    timezone?: boolean
    rate?: boolean
    countryOfResidence?: boolean
    biography?: boolean
    linkedInURL?: boolean
    instagramURL?: boolean
    youtubeURL?: boolean
    spotifyURL?: boolean
    tiktokURL?: boolean
    twitterURL?: boolean
    amazonURL?: boolean
    websiteURL1?: boolean
    websiteURL2?: boolean
    createdAt?: boolean
    refresh_token?: boolean
    isExpert?: boolean
    videos?: boolean
    expertId?: boolean
    provider?: boolean
    otherInfo?: boolean
    is_invited?: boolean
    userName?: boolean
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: boolean
    countryOfResidenceId?: boolean
    dateOfBirth?: boolean
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | User$AppointmentArgs<ExtArgs>
    availabilities?: boolean | User$availabilitiesArgs<ExtArgs>
    Chat?: boolean | User$ChatArgs<ExtArgs>
    messages?: boolean | User$messagesArgs<ExtArgs>
    receivedClientReviews?: boolean | User$receivedClientReviewsArgs<ExtArgs>
    educations?: boolean | User$educationsArgs<ExtArgs>
    experiences?: boolean | User$experiencesArgs<ExtArgs>
    Expert?: boolean | User$ExpertArgs<ExtArgs>
    writtenExpertReviews?: boolean | User$writtenExpertReviewsArgs<ExtArgs>
    expertises?: boolean | User$expertisesArgs<ExtArgs>
    key?: boolean | User$keyArgs<ExtArgs>
    languagesSpoken?: boolean | User$languagesSpokenArgs<ExtArgs>
    Questions?: boolean | User$QuestionsArgs<ExtArgs>
    reply?: boolean | User$replyArgs<ExtArgs>
    admin_expert_application?: boolean | User$admin_expert_applicationArgs<ExtArgs>
    admin_user?: boolean | User$admin_userArgs<ExtArgs>
    email_verification_token?: boolean | User$email_verification_tokenArgs<ExtArgs>
    expertApplicationAnswer?: boolean | User$expertApplicationAnswerArgs<ExtArgs>
    id_verification?: boolean | User$id_verificationArgs<ExtArgs>
    session?: boolean | User$sessionArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      availabilities: Prisma.$AvailabilityPayload<ExtArgs>[]
      Chat: Prisma.$ChatPayload<ExtArgs>[]
      messages: Prisma.$ChatMessagePayload<ExtArgs>[]
      receivedClientReviews: Prisma.$ClientReviewPayload<ExtArgs>[]
      educations: Prisma.$EducationPayload<ExtArgs>[]
      experiences: Prisma.$ExperiencePayload<ExtArgs>[]
      Expert: Prisma.$ExpertPayload<ExtArgs> | null
      writtenExpertReviews: Prisma.$ExpertReviewPayload<ExtArgs>[]
      expertises: Prisma.$ExpertisePayload<ExtArgs>[]
      key: Prisma.$KeyPayload<ExtArgs>[]
      languagesSpoken: Prisma.$LanguagePayload<ExtArgs>[]
      Questions: Prisma.$QuestionPayload<ExtArgs>[]
      reply: Prisma.$ReplyPayload<ExtArgs>[]
      admin_expert_application: Prisma.$admin_expert_applicationPayload<ExtArgs>[]
      admin_user: Prisma.$admin_userPayload<ExtArgs> | null
      email_verification_token: Prisma.$email_verification_tokenPayload<ExtArgs>[]
      expertApplicationAnswer: Prisma.$expertApplicationAnswerPayload<ExtArgs>[]
      id_verification: Prisma.$id_verificationPayload<ExtArgs>[]
      session: Prisma.$sessionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string | null
      lastName: string | null
      email: string
      imageUrl: string | null
      imageName: string | null
      customer_id: string | null
      phone: string | null
      follower: number | null
      role: string | null
      state: string | null
      city: string | null
      zipcode: string | null
      timezone: string | null
      rate: string | null
      countryOfResidence: string | null
      biography: string | null
      linkedInURL: string | null
      instagramURL: string | null
      youtubeURL: string | null
      spotifyURL: string | null
      tiktokURL: string | null
      twitterURL: string | null
      amazonURL: string | null
      websiteURL1: string | null
      websiteURL2: string | null
      createdAt: Date
      refresh_token: string | null
      isExpert: boolean
      videos: string[]
      expertId: string
      provider: string | null
      otherInfo: Prisma.JsonValue | null
      is_invited: number | null
      userName: string | null
      isBanned: boolean
      isAdmin: boolean
      isSubscribed: boolean
      countryOfResidenceISO: $Enums.CountryCode
      countryOfResidenceId: number | null
      dateOfBirth: Date | null
      emailVerified: boolean
      idVerified: boolean
      FavoriteExpertIds: string[]
    }, 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'> & {
      select?: UserCountAggregateInputType | true
    }

  export interface UserDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

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

    /**
     * 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">, never, ExtArgs>

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

    /**
     * Create many Users and returns the data saved in the database.
     * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
     * @example
     * // Create many Users
     * const user = await prisma.user.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Users and only return the `id`
     * const userWithIdOnly = await prisma.user.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>


    /**
     * 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> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends User$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, User$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany"> | Null>
    availabilities<T extends User$availabilitiesArgs<ExtArgs> = {}>(args?: Subset<T, User$availabilitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findMany"> | Null>
    Chat<T extends User$ChatArgs<ExtArgs> = {}>(args?: Subset<T, User$ChatArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findMany"> | Null>
    messages<T extends User$messagesArgs<ExtArgs> = {}>(args?: Subset<T, User$messagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findMany"> | Null>
    receivedClientReviews<T extends User$receivedClientReviewsArgs<ExtArgs> = {}>(args?: Subset<T, User$receivedClientReviewsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findMany"> | Null>
    educations<T extends User$educationsArgs<ExtArgs> = {}>(args?: Subset<T, User$educationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "findMany"> | Null>
    experiences<T extends User$experiencesArgs<ExtArgs> = {}>(args?: Subset<T, User$experiencesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "findMany"> | Null>
    Expert<T extends User$ExpertArgs<ExtArgs> = {}>(args?: Subset<T, User$ExpertArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    writtenExpertReviews<T extends User$writtenExpertReviewsArgs<ExtArgs> = {}>(args?: Subset<T, User$writtenExpertReviewsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findMany"> | Null>
    expertises<T extends User$expertisesArgs<ExtArgs> = {}>(args?: Subset<T, User$expertisesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "findMany"> | Null>
    key<T extends User$keyArgs<ExtArgs> = {}>(args?: Subset<T, User$keyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findMany"> | Null>
    languagesSpoken<T extends User$languagesSpokenArgs<ExtArgs> = {}>(args?: Subset<T, User$languagesSpokenArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "findMany"> | Null>
    Questions<T extends User$QuestionsArgs<ExtArgs> = {}>(args?: Subset<T, User$QuestionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findMany"> | Null>
    reply<T extends User$replyArgs<ExtArgs> = {}>(args?: Subset<T, User$replyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "findMany"> | Null>
    admin_expert_application<T extends User$admin_expert_applicationArgs<ExtArgs> = {}>(args?: Subset<T, User$admin_expert_applicationArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "findMany"> | Null>
    admin_user<T extends User$admin_userArgs<ExtArgs> = {}>(args?: Subset<T, User$admin_userArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    email_verification_token<T extends User$email_verification_tokenArgs<ExtArgs> = {}>(args?: Subset<T, User$email_verification_tokenArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "findMany"> | Null>
    expertApplicationAnswer<T extends User$expertApplicationAnswerArgs<ExtArgs> = {}>(args?: Subset<T, User$expertApplicationAnswerArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findMany"> | Null>
    id_verification<T extends User$id_verificationArgs<ExtArgs> = {}>(args?: Subset<T, User$id_verificationArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "findMany"> | Null>
    session<T extends User$sessionArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$sessionPayload<ExtArgs>, T, "findMany"> | 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 firstName: FieldRef<"User", 'String'>
    readonly lastName: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly imageUrl: FieldRef<"User", 'String'>
    readonly imageName: FieldRef<"User", 'String'>
    readonly customer_id: FieldRef<"User", 'String'>
    readonly phone: FieldRef<"User", 'String'>
    readonly follower: FieldRef<"User", 'Int'>
    readonly role: FieldRef<"User", 'String'>
    readonly state: FieldRef<"User", 'String'>
    readonly city: FieldRef<"User", 'String'>
    readonly zipcode: FieldRef<"User", 'String'>
    readonly timezone: FieldRef<"User", 'String'>
    readonly rate: FieldRef<"User", 'String'>
    readonly countryOfResidence: FieldRef<"User", 'String'>
    readonly biography: FieldRef<"User", 'String'>
    readonly linkedInURL: FieldRef<"User", 'String'>
    readonly instagramURL: FieldRef<"User", 'String'>
    readonly youtubeURL: FieldRef<"User", 'String'>
    readonly spotifyURL: FieldRef<"User", 'String'>
    readonly tiktokURL: FieldRef<"User", 'String'>
    readonly twitterURL: FieldRef<"User", 'String'>
    readonly amazonURL: FieldRef<"User", 'String'>
    readonly websiteURL1: FieldRef<"User", 'String'>
    readonly websiteURL2: FieldRef<"User", 'String'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly refresh_token: FieldRef<"User", 'String'>
    readonly isExpert: FieldRef<"User", 'Boolean'>
    readonly videos: FieldRef<"User", 'String[]'>
    readonly expertId: FieldRef<"User", 'String'>
    readonly provider: FieldRef<"User", 'String'>
    readonly otherInfo: FieldRef<"User", 'Json'>
    readonly is_invited: FieldRef<"User", 'Int'>
    readonly userName: FieldRef<"User", 'String'>
    readonly isBanned: FieldRef<"User", 'Boolean'>
    readonly isAdmin: FieldRef<"User", 'Boolean'>
    readonly isSubscribed: FieldRef<"User", 'Boolean'>
    readonly countryOfResidenceISO: FieldRef<"User", 'CountryCode'>
    readonly countryOfResidenceId: FieldRef<"User", 'Int'>
    readonly dateOfBirth: FieldRef<"User", 'DateTime'>
    readonly emailVerified: FieldRef<"User", 'Boolean'>
    readonly idVerified: FieldRef<"User", 'Boolean'>
    readonly FavoriteExpertIds: 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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 createManyAndReturn
   */
  export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * 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
    /**
     * 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
  }

  /**
   * User upsert
   */
  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<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
    /**
     * 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
  }

  /**
   * User.Appointment
   */
  export type User$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<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[]
  }

  /**
   * User.availabilities
   */
  export type User$availabilitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    where?: AvailabilityWhereInput
    orderBy?: AvailabilityOrderByWithRelationInput | AvailabilityOrderByWithRelationInput[]
    cursor?: AvailabilityWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AvailabilityScalarFieldEnum | AvailabilityScalarFieldEnum[]
  }

  /**
   * User.Chat
   */
  export type User$ChatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    where?: ChatWhereInput
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    cursor?: ChatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * User.messages
   */
  export type User$messagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    where?: ChatMessageWhereInput
    orderBy?: ChatMessageOrderByWithRelationInput | ChatMessageOrderByWithRelationInput[]
    cursor?: ChatMessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChatMessageScalarFieldEnum | ChatMessageScalarFieldEnum[]
  }

  /**
   * User.receivedClientReviews
   */
  export type User$receivedClientReviewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    where?: ClientReviewWhereInput
    orderBy?: ClientReviewOrderByWithRelationInput | ClientReviewOrderByWithRelationInput[]
    cursor?: ClientReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClientReviewScalarFieldEnum | ClientReviewScalarFieldEnum[]
  }

  /**
   * User.educations
   */
  export type User$educationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    where?: EducationWhereInput
    orderBy?: EducationOrderByWithRelationInput | EducationOrderByWithRelationInput[]
    cursor?: EducationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EducationScalarFieldEnum | EducationScalarFieldEnum[]
  }

  /**
   * User.experiences
   */
  export type User$experiencesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    where?: ExperienceWhereInput
    orderBy?: ExperienceOrderByWithRelationInput | ExperienceOrderByWithRelationInput[]
    cursor?: ExperienceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExperienceScalarFieldEnum | ExperienceScalarFieldEnum[]
  }

  /**
   * User.Expert
   */
  export type User$ExpertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    where?: ExpertWhereInput
  }

  /**
   * User.writtenExpertReviews
   */
  export type User$writtenExpertReviewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    where?: ExpertReviewWhereInput
    orderBy?: ExpertReviewOrderByWithRelationInput | ExpertReviewOrderByWithRelationInput[]
    cursor?: ExpertReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertReviewScalarFieldEnum | ExpertReviewScalarFieldEnum[]
  }

  /**
   * User.expertises
   */
  export type User$expertisesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    where?: ExpertiseWhereInput
    orderBy?: ExpertiseOrderByWithRelationInput | ExpertiseOrderByWithRelationInput[]
    cursor?: ExpertiseWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertiseScalarFieldEnum | ExpertiseScalarFieldEnum[]
  }

  /**
   * User.key
   */
  export type User$keyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    where?: KeyWhereInput
    orderBy?: KeyOrderByWithRelationInput | KeyOrderByWithRelationInput[]
    cursor?: KeyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: KeyScalarFieldEnum | KeyScalarFieldEnum[]
  }

  /**
   * User.languagesSpoken
   */
  export type User$languagesSpokenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    where?: LanguageWhereInput
    orderBy?: LanguageOrderByWithRelationInput | LanguageOrderByWithRelationInput[]
    cursor?: LanguageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LanguageScalarFieldEnum | LanguageScalarFieldEnum[]
  }

  /**
   * User.Questions
   */
  export type User$QuestionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    where?: QuestionWhereInput
    orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
    cursor?: QuestionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
  }

  /**
   * User.reply
   */
  export type User$replyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    where?: ReplyWhereInput
    orderBy?: ReplyOrderByWithRelationInput | ReplyOrderByWithRelationInput[]
    cursor?: ReplyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ReplyScalarFieldEnum | ReplyScalarFieldEnum[]
  }

  /**
   * User.admin_expert_application
   */
  export type User$admin_expert_applicationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    where?: admin_expert_applicationWhereInput
    orderBy?: admin_expert_applicationOrderByWithRelationInput | admin_expert_applicationOrderByWithRelationInput[]
    cursor?: admin_expert_applicationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Admin_expert_applicationScalarFieldEnum | Admin_expert_applicationScalarFieldEnum[]
  }

  /**
   * User.admin_user
   */
  export type User$admin_userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    where?: admin_userWhereInput
  }

  /**
   * User.email_verification_token
   */
  export type User$email_verification_tokenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    where?: email_verification_tokenWhereInput
    orderBy?: email_verification_tokenOrderByWithRelationInput | email_verification_tokenOrderByWithRelationInput[]
    cursor?: email_verification_tokenWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Email_verification_tokenScalarFieldEnum | Email_verification_tokenScalarFieldEnum[]
  }

  /**
   * User.expertApplicationAnswer
   */
  export type User$expertApplicationAnswerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    where?: expertApplicationAnswerWhereInput
    orderBy?: expertApplicationAnswerOrderByWithRelationInput | expertApplicationAnswerOrderByWithRelationInput[]
    cursor?: expertApplicationAnswerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertApplicationAnswerScalarFieldEnum | ExpertApplicationAnswerScalarFieldEnum[]
  }

  /**
   * User.id_verification
   */
  export type User$id_verificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    where?: id_verificationWhereInput
    orderBy?: id_verificationOrderByWithRelationInput | id_verificationOrderByWithRelationInput[]
    cursor?: id_verificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Id_verificationScalarFieldEnum | Id_verificationScalarFieldEnum[]
  }

  /**
   * User.session
   */
  export type User$sessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the session
     */
    select?: sessionSelect<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
  }


  /**
   * Model Expert
   */

  export type AggregateExpert = {
    _count: ExpertCountAggregateOutputType | null
    _avg: ExpertAvgAggregateOutputType | null
    _sum: ExpertSumAggregateOutputType | null
    _min: ExpertMinAggregateOutputType | null
    _max: ExpertMaxAggregateOutputType | null
  }

  export type ExpertAvgAggregateOutputType = {
    stripeAccountId: number | null
    countryOfResidenceId: number | null
  }

  export type ExpertSumAggregateOutputType = {
    stripeAccountId: number | null
    countryOfResidenceId: number | null
  }

  export type ExpertMinAggregateOutputType = {
    id: string | null
    stripeAccountId: number | null
    rate: string | null
    timezone: string | null
    user_id: string | null
    isAccepted: boolean | null
    countryOfResidenceId: number | null
    created_at: Date | null
    firstName: string | null
    lastName: string | null
    email: string | null
  }

  export type ExpertMaxAggregateOutputType = {
    id: string | null
    stripeAccountId: number | null
    rate: string | null
    timezone: string | null
    user_id: string | null
    isAccepted: boolean | null
    countryOfResidenceId: number | null
    created_at: Date | null
    firstName: string | null
    lastName: string | null
    email: string | null
  }

  export type ExpertCountAggregateOutputType = {
    id: number
    stripeAccountId: number
    rate: number
    timezone: number
    user_id: number
    isAccepted: number
    countryOfResidenceId: number
    created_at: number
    firstName: number
    lastName: number
    email: number
    _all: number
  }


  export type ExpertAvgAggregateInputType = {
    stripeAccountId?: true
    countryOfResidenceId?: true
  }

  export type ExpertSumAggregateInputType = {
    stripeAccountId?: true
    countryOfResidenceId?: true
  }

  export type ExpertMinAggregateInputType = {
    id?: true
    stripeAccountId?: true
    rate?: true
    timezone?: true
    user_id?: true
    isAccepted?: true
    countryOfResidenceId?: true
    created_at?: true
    firstName?: true
    lastName?: true
    email?: true
  }

  export type ExpertMaxAggregateInputType = {
    id?: true
    stripeAccountId?: true
    rate?: true
    timezone?: true
    user_id?: true
    isAccepted?: true
    countryOfResidenceId?: true
    created_at?: true
    firstName?: true
    lastName?: true
    email?: true
  }

  export type ExpertCountAggregateInputType = {
    id?: true
    stripeAccountId?: true
    rate?: true
    timezone?: true
    user_id?: true
    isAccepted?: true
    countryOfResidenceId?: true
    created_at?: true
    firstName?: true
    lastName?: true
    email?: true
    _all?: true
  }

  export type ExpertAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Expert to aggregate.
     */
    where?: ExpertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Experts to fetch.
     */
    orderBy?: ExpertOrderByWithRelationInput | ExpertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExpertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Experts 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` Experts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Experts
    **/
    _count?: true | ExpertCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExpertAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExpertSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExpertMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExpertMaxAggregateInputType
  }

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




  export type ExpertGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExpertWhereInput
    orderBy?: ExpertOrderByWithAggregationInput | ExpertOrderByWithAggregationInput[]
    by: ExpertScalarFieldEnum[] | ExpertScalarFieldEnum
    having?: ExpertScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertCountAggregateInputType | true
    _avg?: ExpertAvgAggregateInputType
    _sum?: ExpertSumAggregateInputType
    _min?: ExpertMinAggregateInputType
    _max?: ExpertMaxAggregateInputType
  }

  export type ExpertGroupByOutputType = {
    id: string
    stripeAccountId: number | null
    rate: string
    timezone: string
    user_id: string
    isAccepted: boolean
    countryOfResidenceId: number | null
    created_at: Date | null
    firstName: string
    lastName: string
    email: string | null
    _count: ExpertCountAggregateOutputType | null
    _avg: ExpertAvgAggregateOutputType | null
    _sum: ExpertSumAggregateOutputType | null
    _min: ExpertMinAggregateOutputType | null
    _max: ExpertMaxAggregateOutputType | null
  }

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


  export type ExpertSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    stripeAccountId?: boolean
    rate?: boolean
    timezone?: boolean
    user_id?: boolean
    isAccepted?: boolean
    countryOfResidenceId?: boolean
    created_at?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    Appointment?: boolean | Expert$AppointmentArgs<ExtArgs>
    Availabilities?: boolean | Expert$AvailabilitiesArgs<ExtArgs>
    Chat?: boolean | Expert$ChatArgs<ExtArgs>
    ChatMessage?: boolean | Expert$ChatMessageArgs<ExtArgs>
    ClientReview?: boolean | Expert$ClientReviewArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
    ExpertReview?: boolean | Expert$ExpertReviewArgs<ExtArgs>
    StripeAccount?: boolean | Expert$StripeAccountArgs<ExtArgs>
    _count?: boolean | ExpertCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expert"]>

  export type ExpertSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    stripeAccountId?: boolean
    rate?: boolean
    timezone?: boolean
    user_id?: boolean
    isAccepted?: boolean
    countryOfResidenceId?: boolean
    created_at?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expert"]>

  export type ExpertSelectScalar = {
    id?: boolean
    stripeAccountId?: boolean
    rate?: boolean
    timezone?: boolean
    user_id?: boolean
    isAccepted?: boolean
    countryOfResidenceId?: boolean
    created_at?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
  }

  export type ExpertInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | Expert$AppointmentArgs<ExtArgs>
    Availabilities?: boolean | Expert$AvailabilitiesArgs<ExtArgs>
    Chat?: boolean | Expert$ChatArgs<ExtArgs>
    ChatMessage?: boolean | Expert$ChatMessageArgs<ExtArgs>
    ClientReview?: boolean | Expert$ClientReviewArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
    ExpertReview?: boolean | Expert$ExpertReviewArgs<ExtArgs>
    StripeAccount?: boolean | Expert$StripeAccountArgs<ExtArgs>
    _count?: boolean | ExpertCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ExpertIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ExpertPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Expert"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      Availabilities: Prisma.$AvailabilityPayload<ExtArgs>[]
      Chat: Prisma.$ChatPayload<ExtArgs>[]
      ChatMessage: Prisma.$ChatMessagePayload<ExtArgs>[]
      ClientReview: Prisma.$ClientReviewPayload<ExtArgs>[]
      User: Prisma.$UserPayload<ExtArgs>
      ExpertReview: Prisma.$ExpertReviewPayload<ExtArgs>[]
      StripeAccount: Prisma.$StripeAccountPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      stripeAccountId: number | null
      rate: string
      timezone: string
      user_id: string
      isAccepted: boolean
      countryOfResidenceId: number | null
      created_at: Date | null
      firstName: string
      lastName: string
      email: string | null
    }, ExtArgs["result"]["expert"]>
    composites: {}
  }

  type ExpertGetPayload<S extends boolean | null | undefined | ExpertDefaultArgs> = $Result.GetResult<Prisma.$ExpertPayload, S>

  type ExpertCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExpertFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExpertCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Expert 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 {ExpertFindFirstArgs} args - Arguments to find a Expert
     * @example
     * // Get one Expert
     * const expert = await prisma.expert.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExpertFindFirstArgs>(args?: SelectSubset<T, ExpertFindFirstArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Expert 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 {ExpertFindFirstOrThrowArgs} args - Arguments to find a Expert
     * @example
     * // Get one Expert
     * const expert = await prisma.expert.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExpertFindFirstOrThrowArgs>(args?: SelectSubset<T, ExpertFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Experts 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 {ExpertFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Experts
     * const experts = await prisma.expert.findMany()
     * 
     * // Get first 10 Experts
     * const experts = await prisma.expert.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const expertWithIdOnly = await prisma.expert.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExpertFindManyArgs>(args?: SelectSubset<T, ExpertFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Expert.
     * @param {ExpertCreateArgs} args - Arguments to create a Expert.
     * @example
     * // Create one Expert
     * const Expert = await prisma.expert.create({
     *   data: {
     *     // ... data to create a Expert
     *   }
     * })
     * 
     */
    create<T extends ExpertCreateArgs>(args: SelectSubset<T, ExpertCreateArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Experts and returns the data saved in the database.
     * @param {ExpertCreateManyAndReturnArgs} args - Arguments to create many Experts.
     * @example
     * // Create many Experts
     * const expert = await prisma.expert.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Experts and only return the `id`
     * const expertWithIdOnly = await prisma.expert.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ExpertCreateManyAndReturnArgs>(args?: SelectSubset<T, ExpertCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Expert.
     * @param {ExpertDeleteArgs} args - Arguments to delete one Expert.
     * @example
     * // Delete one Expert
     * const Expert = await prisma.expert.delete({
     *   where: {
     *     // ... filter to delete one Expert
     *   }
     * })
     * 
     */
    delete<T extends ExpertDeleteArgs>(args: SelectSubset<T, ExpertDeleteArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Expert.
     * @param {ExpertUpdateArgs} args - Arguments to update one Expert.
     * @example
     * // Update one Expert
     * const expert = await prisma.expert.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExpertUpdateArgs>(args: SelectSubset<T, ExpertUpdateArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Expert.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExpertGroupByArgs} 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 ExpertGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExpertGroupByArgs['orderBy'] }
        : { orderBy?: ExpertGroupByArgs['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, ExpertGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExpertGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Expert model
   */
  readonly fields: ExpertFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Expert.
   * 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__ExpertClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends Expert$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, Expert$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany"> | Null>
    Availabilities<T extends Expert$AvailabilitiesArgs<ExtArgs> = {}>(args?: Subset<T, Expert$AvailabilitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findMany"> | Null>
    Chat<T extends Expert$ChatArgs<ExtArgs> = {}>(args?: Subset<T, Expert$ChatArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findMany"> | Null>
    ChatMessage<T extends Expert$ChatMessageArgs<ExtArgs> = {}>(args?: Subset<T, Expert$ChatMessageArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findMany"> | Null>
    ClientReview<T extends Expert$ClientReviewArgs<ExtArgs> = {}>(args?: Subset<T, Expert$ClientReviewArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findMany"> | Null>
    User<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    ExpertReview<T extends Expert$ExpertReviewArgs<ExtArgs> = {}>(args?: Subset<T, Expert$ExpertReviewArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findMany"> | Null>
    StripeAccount<T extends Expert$StripeAccountArgs<ExtArgs> = {}>(args?: Subset<T, Expert$StripeAccountArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    /**
     * 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 Expert model
   */ 
  interface ExpertFieldRefs {
    readonly id: FieldRef<"Expert", 'String'>
    readonly stripeAccountId: FieldRef<"Expert", 'Int'>
    readonly rate: FieldRef<"Expert", 'String'>
    readonly timezone: FieldRef<"Expert", 'String'>
    readonly user_id: FieldRef<"Expert", 'String'>
    readonly isAccepted: FieldRef<"Expert", 'Boolean'>
    readonly countryOfResidenceId: FieldRef<"Expert", 'Int'>
    readonly created_at: FieldRef<"Expert", 'DateTime'>
    readonly firstName: FieldRef<"Expert", 'String'>
    readonly lastName: FieldRef<"Expert", 'String'>
    readonly email: FieldRef<"Expert", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Expert findUnique
   */
  export type ExpertFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * Filter, which Expert to fetch.
     */
    where: ExpertWhereUniqueInput
  }

  /**
   * Expert findUniqueOrThrow
   */
  export type ExpertFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * Filter, which Expert to fetch.
     */
    where: ExpertWhereUniqueInput
  }

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

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

  /**
   * Expert findMany
   */
  export type ExpertFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * Filter, which Experts to fetch.
     */
    where?: ExpertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Experts to fetch.
     */
    orderBy?: ExpertOrderByWithRelationInput | ExpertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Experts.
     */
    cursor?: ExpertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Experts 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` Experts.
     */
    skip?: number
    distinct?: ExpertScalarFieldEnum | ExpertScalarFieldEnum[]
  }

  /**
   * Expert create
   */
  export type ExpertCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * The data needed to create a Expert.
     */
    data: XOR<ExpertCreateInput, ExpertUncheckedCreateInput>
  }

  /**
   * Expert createMany
   */
  export type ExpertCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Experts.
     */
    data: ExpertCreateManyInput | ExpertCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Expert createManyAndReturn
   */
  export type ExpertCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Experts.
     */
    data: ExpertCreateManyInput | ExpertCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Expert update
   */
  export type ExpertUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * The data needed to update a Expert.
     */
    data: XOR<ExpertUpdateInput, ExpertUncheckedUpdateInput>
    /**
     * Choose, which Expert to update.
     */
    where: ExpertWhereUniqueInput
  }

  /**
   * Expert updateMany
   */
  export type ExpertUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Experts.
     */
    data: XOR<ExpertUpdateManyMutationInput, ExpertUncheckedUpdateManyInput>
    /**
     * Filter which Experts to update
     */
    where?: ExpertWhereInput
  }

  /**
   * Expert upsert
   */
  export type ExpertUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * The filter to search for the Expert to update in case it exists.
     */
    where: ExpertWhereUniqueInput
    /**
     * In case the Expert found by the `where` argument doesn't exist, create a new Expert with this data.
     */
    create: XOR<ExpertCreateInput, ExpertUncheckedCreateInput>
    /**
     * In case the Expert was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExpertUpdateInput, ExpertUncheckedUpdateInput>
  }

  /**
   * Expert delete
   */
  export type ExpertDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    /**
     * Filter which Expert to delete.
     */
    where: ExpertWhereUniqueInput
  }

  /**
   * Expert deleteMany
   */
  export type ExpertDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Experts to delete
     */
    where?: ExpertWhereInput
  }

  /**
   * Expert.Appointment
   */
  export type Expert$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<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[]
  }

  /**
   * Expert.Availabilities
   */
  export type Expert$AvailabilitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    where?: AvailabilityWhereInput
    orderBy?: AvailabilityOrderByWithRelationInput | AvailabilityOrderByWithRelationInput[]
    cursor?: AvailabilityWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AvailabilityScalarFieldEnum | AvailabilityScalarFieldEnum[]
  }

  /**
   * Expert.Chat
   */
  export type Expert$ChatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    where?: ChatWhereInput
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    cursor?: ChatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * Expert.ChatMessage
   */
  export type Expert$ChatMessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    where?: ChatMessageWhereInput
    orderBy?: ChatMessageOrderByWithRelationInput | ChatMessageOrderByWithRelationInput[]
    cursor?: ChatMessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChatMessageScalarFieldEnum | ChatMessageScalarFieldEnum[]
  }

  /**
   * Expert.ClientReview
   */
  export type Expert$ClientReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    where?: ClientReviewWhereInput
    orderBy?: ClientReviewOrderByWithRelationInput | ClientReviewOrderByWithRelationInput[]
    cursor?: ClientReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClientReviewScalarFieldEnum | ClientReviewScalarFieldEnum[]
  }

  /**
   * Expert.ExpertReview
   */
  export type Expert$ExpertReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    where?: ExpertReviewWhereInput
    orderBy?: ExpertReviewOrderByWithRelationInput | ExpertReviewOrderByWithRelationInput[]
    cursor?: ExpertReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertReviewScalarFieldEnum | ExpertReviewScalarFieldEnum[]
  }

  /**
   * Expert.StripeAccount
   */
  export type Expert$StripeAccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    where?: StripeAccountWhereInput
  }

  /**
   * Expert without action
   */
  export type ExpertDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
  }


  /**
   * Model id_verification
   */

  export type AggregateId_verification = {
    _count: Id_verificationCountAggregateOutputType | null
    _avg: Id_verificationAvgAggregateOutputType | null
    _sum: Id_verificationSumAggregateOutputType | null
    _min: Id_verificationMinAggregateOutputType | null
    _max: Id_verificationMaxAggregateOutputType | null
  }

  export type Id_verificationAvgAggregateOutputType = {
    id: number | null
  }

  export type Id_verificationSumAggregateOutputType = {
    id: number | null
  }

  export type Id_verificationMinAggregateOutputType = {
    id: number | null
    status: $Enums.Status | null
    userId: string | null
    idImageUrlBack: string | null
    idImageUrlFront: string | null
    createdAt: Date | null
    documentType: $Enums.documentType | null
  }

  export type Id_verificationMaxAggregateOutputType = {
    id: number | null
    status: $Enums.Status | null
    userId: string | null
    idImageUrlBack: string | null
    idImageUrlFront: string | null
    createdAt: Date | null
    documentType: $Enums.documentType | null
  }

  export type Id_verificationCountAggregateOutputType = {
    id: number
    status: number
    userId: number
    idImageUrlBack: number
    idImageUrlFront: number
    createdAt: number
    documentType: number
    _all: number
  }


  export type Id_verificationAvgAggregateInputType = {
    id?: true
  }

  export type Id_verificationSumAggregateInputType = {
    id?: true
  }

  export type Id_verificationMinAggregateInputType = {
    id?: true
    status?: true
    userId?: true
    idImageUrlBack?: true
    idImageUrlFront?: true
    createdAt?: true
    documentType?: true
  }

  export type Id_verificationMaxAggregateInputType = {
    id?: true
    status?: true
    userId?: true
    idImageUrlBack?: true
    idImageUrlFront?: true
    createdAt?: true
    documentType?: true
  }

  export type Id_verificationCountAggregateInputType = {
    id?: true
    status?: true
    userId?: true
    idImageUrlBack?: true
    idImageUrlFront?: true
    createdAt?: true
    documentType?: true
    _all?: true
  }

  export type Id_verificationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which id_verification to aggregate.
     */
    where?: id_verificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of id_verifications to fetch.
     */
    orderBy?: id_verificationOrderByWithRelationInput | id_verificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: id_verificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` id_verifications 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` id_verifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned id_verifications
    **/
    _count?: true | Id_verificationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Id_verificationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Id_verificationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Id_verificationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Id_verificationMaxAggregateInputType
  }

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




  export type id_verificationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: id_verificationWhereInput
    orderBy?: id_verificationOrderByWithAggregationInput | id_verificationOrderByWithAggregationInput[]
    by: Id_verificationScalarFieldEnum[] | Id_verificationScalarFieldEnum
    having?: id_verificationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Id_verificationCountAggregateInputType | true
    _avg?: Id_verificationAvgAggregateInputType
    _sum?: Id_verificationSumAggregateInputType
    _min?: Id_verificationMinAggregateInputType
    _max?: Id_verificationMaxAggregateInputType
  }

  export type Id_verificationGroupByOutputType = {
    id: number
    status: $Enums.Status
    userId: string
    idImageUrlBack: string | null
    idImageUrlFront: string
    createdAt: Date
    documentType: $Enums.documentType
    _count: Id_verificationCountAggregateOutputType | null
    _avg: Id_verificationAvgAggregateOutputType | null
    _sum: Id_verificationSumAggregateOutputType | null
    _min: Id_verificationMinAggregateOutputType | null
    _max: Id_verificationMaxAggregateOutputType | null
  }

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


  export type id_verificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    userId?: boolean
    idImageUrlBack?: boolean
    idImageUrlFront?: boolean
    createdAt?: boolean
    documentType?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["id_verification"]>

  export type id_verificationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    userId?: boolean
    idImageUrlBack?: boolean
    idImageUrlFront?: boolean
    createdAt?: boolean
    documentType?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["id_verification"]>

  export type id_verificationSelectScalar = {
    id?: boolean
    status?: boolean
    userId?: boolean
    idImageUrlBack?: boolean
    idImageUrlFront?: boolean
    createdAt?: boolean
    documentType?: boolean
  }

  export type id_verificationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type id_verificationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $id_verificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "id_verification"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      status: $Enums.Status
      userId: string
      idImageUrlBack: string | null
      idImageUrlFront: string
      createdAt: Date
      documentType: $Enums.documentType
    }, ExtArgs["result"]["id_verification"]>
    composites: {}
  }

  type id_verificationGetPayload<S extends boolean | null | undefined | id_verificationDefaultArgs> = $Result.GetResult<Prisma.$id_verificationPayload, S>

  type id_verificationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<id_verificationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Id_verificationCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Id_verification 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 {id_verificationFindFirstArgs} args - Arguments to find a Id_verification
     * @example
     * // Get one Id_verification
     * const id_verification = await prisma.id_verification.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends id_verificationFindFirstArgs>(args?: SelectSubset<T, id_verificationFindFirstArgs<ExtArgs>>): Prisma__id_verificationClient<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Id_verification 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 {id_verificationFindFirstOrThrowArgs} args - Arguments to find a Id_verification
     * @example
     * // Get one Id_verification
     * const id_verification = await prisma.id_verification.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends id_verificationFindFirstOrThrowArgs>(args?: SelectSubset<T, id_verificationFindFirstOrThrowArgs<ExtArgs>>): Prisma__id_verificationClient<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Id_verifications 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 {id_verificationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Id_verifications
     * const id_verifications = await prisma.id_verification.findMany()
     * 
     * // Get first 10 Id_verifications
     * const id_verifications = await prisma.id_verification.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const id_verificationWithIdOnly = await prisma.id_verification.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends id_verificationFindManyArgs>(args?: SelectSubset<T, id_verificationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Id_verification.
     * @param {id_verificationCreateArgs} args - Arguments to create a Id_verification.
     * @example
     * // Create one Id_verification
     * const Id_verification = await prisma.id_verification.create({
     *   data: {
     *     // ... data to create a Id_verification
     *   }
     * })
     * 
     */
    create<T extends id_verificationCreateArgs>(args: SelectSubset<T, id_verificationCreateArgs<ExtArgs>>): Prisma__id_verificationClient<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Id_verifications and returns the data saved in the database.
     * @param {id_verificationCreateManyAndReturnArgs} args - Arguments to create many Id_verifications.
     * @example
     * // Create many Id_verifications
     * const id_verification = await prisma.id_verification.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Id_verifications and only return the `id`
     * const id_verificationWithIdOnly = await prisma.id_verification.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends id_verificationCreateManyAndReturnArgs>(args?: SelectSubset<T, id_verificationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Id_verification.
     * @param {id_verificationDeleteArgs} args - Arguments to delete one Id_verification.
     * @example
     * // Delete one Id_verification
     * const Id_verification = await prisma.id_verification.delete({
     *   where: {
     *     // ... filter to delete one Id_verification
     *   }
     * })
     * 
     */
    delete<T extends id_verificationDeleteArgs>(args: SelectSubset<T, id_verificationDeleteArgs<ExtArgs>>): Prisma__id_verificationClient<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Id_verification.
     * @param {id_verificationUpdateArgs} args - Arguments to update one Id_verification.
     * @example
     * // Update one Id_verification
     * const id_verification = await prisma.id_verification.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends id_verificationUpdateArgs>(args: SelectSubset<T, id_verificationUpdateArgs<ExtArgs>>): Prisma__id_verificationClient<$Result.GetResult<Prisma.$id_verificationPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Id_verification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {id_verificationGroupByArgs} 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 id_verificationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: id_verificationGroupByArgs['orderBy'] }
        : { orderBy?: id_verificationGroupByArgs['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, id_verificationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetId_verificationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the id_verification model
   */
  readonly fields: id_verificationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for id_verification.
   * 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__id_verificationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 id_verification model
   */ 
  interface id_verificationFieldRefs {
    readonly id: FieldRef<"id_verification", 'Int'>
    readonly status: FieldRef<"id_verification", 'Status'>
    readonly userId: FieldRef<"id_verification", 'String'>
    readonly idImageUrlBack: FieldRef<"id_verification", 'String'>
    readonly idImageUrlFront: FieldRef<"id_verification", 'String'>
    readonly createdAt: FieldRef<"id_verification", 'DateTime'>
    readonly documentType: FieldRef<"id_verification", 'documentType'>
  }
    

  // Custom InputTypes
  /**
   * id_verification findUnique
   */
  export type id_verificationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * Filter, which id_verification to fetch.
     */
    where: id_verificationWhereUniqueInput
  }

  /**
   * id_verification findUniqueOrThrow
   */
  export type id_verificationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * Filter, which id_verification to fetch.
     */
    where: id_verificationWhereUniqueInput
  }

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

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

  /**
   * id_verification findMany
   */
  export type id_verificationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * Filter, which id_verifications to fetch.
     */
    where?: id_verificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of id_verifications to fetch.
     */
    orderBy?: id_verificationOrderByWithRelationInput | id_verificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing id_verifications.
     */
    cursor?: id_verificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` id_verifications 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` id_verifications.
     */
    skip?: number
    distinct?: Id_verificationScalarFieldEnum | Id_verificationScalarFieldEnum[]
  }

  /**
   * id_verification create
   */
  export type id_verificationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * The data needed to create a id_verification.
     */
    data: XOR<id_verificationCreateInput, id_verificationUncheckedCreateInput>
  }

  /**
   * id_verification createMany
   */
  export type id_verificationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many id_verifications.
     */
    data: id_verificationCreateManyInput | id_verificationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * id_verification createManyAndReturn
   */
  export type id_verificationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many id_verifications.
     */
    data: id_verificationCreateManyInput | id_verificationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * id_verification update
   */
  export type id_verificationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * The data needed to update a id_verification.
     */
    data: XOR<id_verificationUpdateInput, id_verificationUncheckedUpdateInput>
    /**
     * Choose, which id_verification to update.
     */
    where: id_verificationWhereUniqueInput
  }

  /**
   * id_verification updateMany
   */
  export type id_verificationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update id_verifications.
     */
    data: XOR<id_verificationUpdateManyMutationInput, id_verificationUncheckedUpdateManyInput>
    /**
     * Filter which id_verifications to update
     */
    where?: id_verificationWhereInput
  }

  /**
   * id_verification upsert
   */
  export type id_verificationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * The filter to search for the id_verification to update in case it exists.
     */
    where: id_verificationWhereUniqueInput
    /**
     * In case the id_verification found by the `where` argument doesn't exist, create a new id_verification with this data.
     */
    create: XOR<id_verificationCreateInput, id_verificationUncheckedCreateInput>
    /**
     * In case the id_verification was found with the provided `where` argument, update it with this data.
     */
    update: XOR<id_verificationUpdateInput, id_verificationUncheckedUpdateInput>
  }

  /**
   * id_verification delete
   */
  export type id_verificationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
    /**
     * Filter which id_verification to delete.
     */
    where: id_verificationWhereUniqueInput
  }

  /**
   * id_verification deleteMany
   */
  export type id_verificationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which id_verifications to delete
     */
    where?: id_verificationWhereInput
  }

  /**
   * id_verification without action
   */
  export type id_verificationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the id_verification
     */
    select?: id_verificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: id_verificationInclude<ExtArgs> | null
  }


  /**
   * Model email_verification_token
   */

  export type AggregateEmail_verification_token = {
    _count: Email_verification_tokenCountAggregateOutputType | null
    _avg: Email_verification_tokenAvgAggregateOutputType | null
    _sum: Email_verification_tokenSumAggregateOutputType | null
    _min: Email_verification_tokenMinAggregateOutputType | null
    _max: Email_verification_tokenMaxAggregateOutputType | null
  }

  export type Email_verification_tokenAvgAggregateOutputType = {
    expires: number | null
  }

  export type Email_verification_tokenSumAggregateOutputType = {
    expires: bigint | null
  }

  export type Email_verification_tokenMinAggregateOutputType = {
    id: string | null
    expires: bigint | null
    userId: string | null
  }

  export type Email_verification_tokenMaxAggregateOutputType = {
    id: string | null
    expires: bigint | null
    userId: string | null
  }

  export type Email_verification_tokenCountAggregateOutputType = {
    id: number
    expires: number
    userId: number
    _all: number
  }


  export type Email_verification_tokenAvgAggregateInputType = {
    expires?: true
  }

  export type Email_verification_tokenSumAggregateInputType = {
    expires?: true
  }

  export type Email_verification_tokenMinAggregateInputType = {
    id?: true
    expires?: true
    userId?: true
  }

  export type Email_verification_tokenMaxAggregateInputType = {
    id?: true
    expires?: true
    userId?: true
  }

  export type Email_verification_tokenCountAggregateInputType = {
    id?: true
    expires?: true
    userId?: true
    _all?: true
  }

  export type Email_verification_tokenAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which email_verification_token to aggregate.
     */
    where?: email_verification_tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of email_verification_tokens to fetch.
     */
    orderBy?: email_verification_tokenOrderByWithRelationInput | email_verification_tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: email_verification_tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` email_verification_tokens 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` email_verification_tokens.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned email_verification_tokens
    **/
    _count?: true | Email_verification_tokenCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Email_verification_tokenAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Email_verification_tokenSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Email_verification_tokenMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Email_verification_tokenMaxAggregateInputType
  }

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




  export type email_verification_tokenGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: email_verification_tokenWhereInput
    orderBy?: email_verification_tokenOrderByWithAggregationInput | email_verification_tokenOrderByWithAggregationInput[]
    by: Email_verification_tokenScalarFieldEnum[] | Email_verification_tokenScalarFieldEnum
    having?: email_verification_tokenScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Email_verification_tokenCountAggregateInputType | true
    _avg?: Email_verification_tokenAvgAggregateInputType
    _sum?: Email_verification_tokenSumAggregateInputType
    _min?: Email_verification_tokenMinAggregateInputType
    _max?: Email_verification_tokenMaxAggregateInputType
  }

  export type Email_verification_tokenGroupByOutputType = {
    id: string
    expires: bigint
    userId: string
    _count: Email_verification_tokenCountAggregateOutputType | null
    _avg: Email_verification_tokenAvgAggregateOutputType | null
    _sum: Email_verification_tokenSumAggregateOutputType | null
    _min: Email_verification_tokenMinAggregateOutputType | null
    _max: Email_verification_tokenMaxAggregateOutputType | null
  }

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


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

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

  export type email_verification_tokenSelectScalar = {
    id?: boolean
    expires?: boolean
    userId?: boolean
  }

  export type email_verification_tokenInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type email_verification_tokenIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $email_verification_tokenPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "email_verification_token"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      expires: bigint
      userId: string
    }, ExtArgs["result"]["email_verification_token"]>
    composites: {}
  }

  type email_verification_tokenGetPayload<S extends boolean | null | undefined | email_verification_tokenDefaultArgs> = $Result.GetResult<Prisma.$email_verification_tokenPayload, S>

  type email_verification_tokenCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<email_verification_tokenFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Email_verification_tokenCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Email_verification_token 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 {email_verification_tokenFindFirstArgs} args - Arguments to find a Email_verification_token
     * @example
     * // Get one Email_verification_token
     * const email_verification_token = await prisma.email_verification_token.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends email_verification_tokenFindFirstArgs>(args?: SelectSubset<T, email_verification_tokenFindFirstArgs<ExtArgs>>): Prisma__email_verification_tokenClient<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Email_verification_token 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 {email_verification_tokenFindFirstOrThrowArgs} args - Arguments to find a Email_verification_token
     * @example
     * // Get one Email_verification_token
     * const email_verification_token = await prisma.email_verification_token.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends email_verification_tokenFindFirstOrThrowArgs>(args?: SelectSubset<T, email_verification_tokenFindFirstOrThrowArgs<ExtArgs>>): Prisma__email_verification_tokenClient<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Email_verification_tokens 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 {email_verification_tokenFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Email_verification_tokens
     * const email_verification_tokens = await prisma.email_verification_token.findMany()
     * 
     * // Get first 10 Email_verification_tokens
     * const email_verification_tokens = await prisma.email_verification_token.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const email_verification_tokenWithIdOnly = await prisma.email_verification_token.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends email_verification_tokenFindManyArgs>(args?: SelectSubset<T, email_verification_tokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Email_verification_token.
     * @param {email_verification_tokenCreateArgs} args - Arguments to create a Email_verification_token.
     * @example
     * // Create one Email_verification_token
     * const Email_verification_token = await prisma.email_verification_token.create({
     *   data: {
     *     // ... data to create a Email_verification_token
     *   }
     * })
     * 
     */
    create<T extends email_verification_tokenCreateArgs>(args: SelectSubset<T, email_verification_tokenCreateArgs<ExtArgs>>): Prisma__email_verification_tokenClient<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Email_verification_tokens and returns the data saved in the database.
     * @param {email_verification_tokenCreateManyAndReturnArgs} args - Arguments to create many Email_verification_tokens.
     * @example
     * // Create many Email_verification_tokens
     * const email_verification_token = await prisma.email_verification_token.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Email_verification_tokens and only return the `id`
     * const email_verification_tokenWithIdOnly = await prisma.email_verification_token.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends email_verification_tokenCreateManyAndReturnArgs>(args?: SelectSubset<T, email_verification_tokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Email_verification_token.
     * @param {email_verification_tokenDeleteArgs} args - Arguments to delete one Email_verification_token.
     * @example
     * // Delete one Email_verification_token
     * const Email_verification_token = await prisma.email_verification_token.delete({
     *   where: {
     *     // ... filter to delete one Email_verification_token
     *   }
     * })
     * 
     */
    delete<T extends email_verification_tokenDeleteArgs>(args: SelectSubset<T, email_verification_tokenDeleteArgs<ExtArgs>>): Prisma__email_verification_tokenClient<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Email_verification_token.
     * @param {email_verification_tokenUpdateArgs} args - Arguments to update one Email_verification_token.
     * @example
     * // Update one Email_verification_token
     * const email_verification_token = await prisma.email_verification_token.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends email_verification_tokenUpdateArgs>(args: SelectSubset<T, email_verification_tokenUpdateArgs<ExtArgs>>): Prisma__email_verification_tokenClient<$Result.GetResult<Prisma.$email_verification_tokenPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Email_verification_token.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {email_verification_tokenGroupByArgs} 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 email_verification_tokenGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: email_verification_tokenGroupByArgs['orderBy'] }
        : { orderBy?: email_verification_tokenGroupByArgs['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, email_verification_tokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEmail_verification_tokenGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the email_verification_token model
   */
  readonly fields: email_verification_tokenFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for email_verification_token.
   * 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__email_verification_tokenClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 email_verification_token model
   */ 
  interface email_verification_tokenFieldRefs {
    readonly id: FieldRef<"email_verification_token", 'String'>
    readonly expires: FieldRef<"email_verification_token", 'BigInt'>
    readonly userId: FieldRef<"email_verification_token", 'String'>
  }
    

  // Custom InputTypes
  /**
   * email_verification_token findUnique
   */
  export type email_verification_tokenFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * Filter, which email_verification_token to fetch.
     */
    where: email_verification_tokenWhereUniqueInput
  }

  /**
   * email_verification_token findUniqueOrThrow
   */
  export type email_verification_tokenFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * Filter, which email_verification_token to fetch.
     */
    where: email_verification_tokenWhereUniqueInput
  }

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

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

  /**
   * email_verification_token findMany
   */
  export type email_verification_tokenFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * Filter, which email_verification_tokens to fetch.
     */
    where?: email_verification_tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of email_verification_tokens to fetch.
     */
    orderBy?: email_verification_tokenOrderByWithRelationInput | email_verification_tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing email_verification_tokens.
     */
    cursor?: email_verification_tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` email_verification_tokens 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` email_verification_tokens.
     */
    skip?: number
    distinct?: Email_verification_tokenScalarFieldEnum | Email_verification_tokenScalarFieldEnum[]
  }

  /**
   * email_verification_token create
   */
  export type email_verification_tokenCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * The data needed to create a email_verification_token.
     */
    data: XOR<email_verification_tokenCreateInput, email_verification_tokenUncheckedCreateInput>
  }

  /**
   * email_verification_token createMany
   */
  export type email_verification_tokenCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many email_verification_tokens.
     */
    data: email_verification_tokenCreateManyInput | email_verification_tokenCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * email_verification_token createManyAndReturn
   */
  export type email_verification_tokenCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many email_verification_tokens.
     */
    data: email_verification_tokenCreateManyInput | email_verification_tokenCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * email_verification_token update
   */
  export type email_verification_tokenUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * The data needed to update a email_verification_token.
     */
    data: XOR<email_verification_tokenUpdateInput, email_verification_tokenUncheckedUpdateInput>
    /**
     * Choose, which email_verification_token to update.
     */
    where: email_verification_tokenWhereUniqueInput
  }

  /**
   * email_verification_token updateMany
   */
  export type email_verification_tokenUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update email_verification_tokens.
     */
    data: XOR<email_verification_tokenUpdateManyMutationInput, email_verification_tokenUncheckedUpdateManyInput>
    /**
     * Filter which email_verification_tokens to update
     */
    where?: email_verification_tokenWhereInput
  }

  /**
   * email_verification_token upsert
   */
  export type email_verification_tokenUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * The filter to search for the email_verification_token to update in case it exists.
     */
    where: email_verification_tokenWhereUniqueInput
    /**
     * In case the email_verification_token found by the `where` argument doesn't exist, create a new email_verification_token with this data.
     */
    create: XOR<email_verification_tokenCreateInput, email_verification_tokenUncheckedCreateInput>
    /**
     * In case the email_verification_token was found with the provided `where` argument, update it with this data.
     */
    update: XOR<email_verification_tokenUpdateInput, email_verification_tokenUncheckedUpdateInput>
  }

  /**
   * email_verification_token delete
   */
  export type email_verification_tokenDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
    /**
     * Filter which email_verification_token to delete.
     */
    where: email_verification_tokenWhereUniqueInput
  }

  /**
   * email_verification_token deleteMany
   */
  export type email_verification_tokenDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which email_verification_tokens to delete
     */
    where?: email_verification_tokenWhereInput
  }

  /**
   * email_verification_token without action
   */
  export type email_verification_tokenDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the email_verification_token
     */
    select?: email_verification_tokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: email_verification_tokenInclude<ExtArgs> | null
  }


  /**
   * Model Question
   */

  export type AggregateQuestion = {
    _count: QuestionCountAggregateOutputType | null
    _avg: QuestionAvgAggregateOutputType | null
    _sum: QuestionSumAggregateOutputType | null
    _min: QuestionMinAggregateOutputType | null
    _max: QuestionMaxAggregateOutputType | null
  }

  export type QuestionAvgAggregateOutputType = {
    id: number | null
  }

  export type QuestionSumAggregateOutputType = {
    id: number | null
  }

  export type QuestionMinAggregateOutputType = {
    id: number | null
    content: string | null
    userId: string | null
  }

  export type QuestionMaxAggregateOutputType = {
    id: number | null
    content: string | null
    userId: string | null
  }

  export type QuestionCountAggregateOutputType = {
    id: number
    content: number
    userId: number
    _all: number
  }


  export type QuestionAvgAggregateInputType = {
    id?: true
  }

  export type QuestionSumAggregateInputType = {
    id?: true
  }

  export type QuestionMinAggregateInputType = {
    id?: true
    content?: true
    userId?: true
  }

  export type QuestionMaxAggregateInputType = {
    id?: true
    content?: true
    userId?: true
  }

  export type QuestionCountAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    _all?: true
  }

  export type QuestionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Question to aggregate.
     */
    where?: QuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Questions to fetch.
     */
    orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: QuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Questions 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` Questions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Questions
    **/
    _count?: true | QuestionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: QuestionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: QuestionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: QuestionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: QuestionMaxAggregateInputType
  }

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




  export type QuestionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuestionWhereInput
    orderBy?: QuestionOrderByWithAggregationInput | QuestionOrderByWithAggregationInput[]
    by: QuestionScalarFieldEnum[] | QuestionScalarFieldEnum
    having?: QuestionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: QuestionCountAggregateInputType | true
    _avg?: QuestionAvgAggregateInputType
    _sum?: QuestionSumAggregateInputType
    _min?: QuestionMinAggregateInputType
    _max?: QuestionMaxAggregateInputType
  }

  export type QuestionGroupByOutputType = {
    id: number
    content: string
    userId: string
    _count: QuestionCountAggregateOutputType | null
    _avg: QuestionAvgAggregateOutputType | null
    _sum: QuestionSumAggregateOutputType | null
    _min: QuestionMinAggregateOutputType | null
    _max: QuestionMaxAggregateOutputType | null
  }

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


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

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

  export type QuestionSelectScalar = {
    id?: boolean
    content?: boolean
    userId?: boolean
  }

  export type QuestionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type QuestionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $QuestionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Question"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      content: string
      userId: string
    }, ExtArgs["result"]["question"]>
    composites: {}
  }

  type QuestionGetPayload<S extends boolean | null | undefined | QuestionDefaultArgs> = $Result.GetResult<Prisma.$QuestionPayload, S>

  type QuestionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<QuestionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: QuestionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Question 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 {QuestionFindFirstArgs} args - Arguments to find a Question
     * @example
     * // Get one Question
     * const question = await prisma.question.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends QuestionFindFirstArgs>(args?: SelectSubset<T, QuestionFindFirstArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Question 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 {QuestionFindFirstOrThrowArgs} args - Arguments to find a Question
     * @example
     * // Get one Question
     * const question = await prisma.question.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends QuestionFindFirstOrThrowArgs>(args?: SelectSubset<T, QuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Questions 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 {QuestionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Questions
     * const questions = await prisma.question.findMany()
     * 
     * // Get first 10 Questions
     * const questions = await prisma.question.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const questionWithIdOnly = await prisma.question.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends QuestionFindManyArgs>(args?: SelectSubset<T, QuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Question.
     * @param {QuestionCreateArgs} args - Arguments to create a Question.
     * @example
     * // Create one Question
     * const Question = await prisma.question.create({
     *   data: {
     *     // ... data to create a Question
     *   }
     * })
     * 
     */
    create<T extends QuestionCreateArgs>(args: SelectSubset<T, QuestionCreateArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Questions and returns the data saved in the database.
     * @param {QuestionCreateManyAndReturnArgs} args - Arguments to create many Questions.
     * @example
     * // Create many Questions
     * const question = await prisma.question.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Questions and only return the `id`
     * const questionWithIdOnly = await prisma.question.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends QuestionCreateManyAndReturnArgs>(args?: SelectSubset<T, QuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Question.
     * @param {QuestionDeleteArgs} args - Arguments to delete one Question.
     * @example
     * // Delete one Question
     * const Question = await prisma.question.delete({
     *   where: {
     *     // ... filter to delete one Question
     *   }
     * })
     * 
     */
    delete<T extends QuestionDeleteArgs>(args: SelectSubset<T, QuestionDeleteArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Question.
     * @param {QuestionUpdateArgs} args - Arguments to update one Question.
     * @example
     * // Update one Question
     * const question = await prisma.question.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends QuestionUpdateArgs>(args: SelectSubset<T, QuestionUpdateArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Question.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuestionGroupByArgs} 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 QuestionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: QuestionGroupByArgs['orderBy'] }
        : { orderBy?: QuestionGroupByArgs['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, QuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Question model
   */
  readonly fields: QuestionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Question.
   * 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__QuestionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Question model
   */ 
  interface QuestionFieldRefs {
    readonly id: FieldRef<"Question", 'Int'>
    readonly content: FieldRef<"Question", 'String'>
    readonly userId: FieldRef<"Question", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Question findUnique
   */
  export type QuestionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * Filter, which Question to fetch.
     */
    where: QuestionWhereUniqueInput
  }

  /**
   * Question findUniqueOrThrow
   */
  export type QuestionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * Filter, which Question to fetch.
     */
    where: QuestionWhereUniqueInput
  }

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

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

  /**
   * Question findMany
   */
  export type QuestionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * Filter, which Questions to fetch.
     */
    where?: QuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Questions to fetch.
     */
    orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Questions.
     */
    cursor?: QuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Questions 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` Questions.
     */
    skip?: number
    distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
  }

  /**
   * Question create
   */
  export type QuestionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * The data needed to create a Question.
     */
    data: XOR<QuestionCreateInput, QuestionUncheckedCreateInput>
  }

  /**
   * Question createMany
   */
  export type QuestionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Questions.
     */
    data: QuestionCreateManyInput | QuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Question createManyAndReturn
   */
  export type QuestionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Questions.
     */
    data: QuestionCreateManyInput | QuestionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Question update
   */
  export type QuestionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * The data needed to update a Question.
     */
    data: XOR<QuestionUpdateInput, QuestionUncheckedUpdateInput>
    /**
     * Choose, which Question to update.
     */
    where: QuestionWhereUniqueInput
  }

  /**
   * Question updateMany
   */
  export type QuestionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Questions.
     */
    data: XOR<QuestionUpdateManyMutationInput, QuestionUncheckedUpdateManyInput>
    /**
     * Filter which Questions to update
     */
    where?: QuestionWhereInput
  }

  /**
   * Question upsert
   */
  export type QuestionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * The filter to search for the Question to update in case it exists.
     */
    where: QuestionWhereUniqueInput
    /**
     * In case the Question found by the `where` argument doesn't exist, create a new Question with this data.
     */
    create: XOR<QuestionCreateInput, QuestionUncheckedCreateInput>
    /**
     * In case the Question was found with the provided `where` argument, update it with this data.
     */
    update: XOR<QuestionUpdateInput, QuestionUncheckedUpdateInput>
  }

  /**
   * Question delete
   */
  export type QuestionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
    /**
     * Filter which Question to delete.
     */
    where: QuestionWhereUniqueInput
  }

  /**
   * Question deleteMany
   */
  export type QuestionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Questions to delete
     */
    where?: QuestionWhereInput
  }

  /**
   * Question without action
   */
  export type QuestionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Question
     */
    select?: QuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuestionInclude<ExtArgs> | null
  }


  /**
   * Model Reply
   */

  export type AggregateReply = {
    _count: ReplyCountAggregateOutputType | null
    _avg: ReplyAvgAggregateOutputType | null
    _sum: ReplySumAggregateOutputType | null
    _min: ReplyMinAggregateOutputType | null
    _max: ReplyMaxAggregateOutputType | null
  }

  export type ReplyAvgAggregateOutputType = {
    id: number | null
  }

  export type ReplySumAggregateOutputType = {
    id: number | null
  }

  export type ReplyMinAggregateOutputType = {
    id: number | null
    content: string | null
    appointmentKey: string | null
    questionContent: string | null
    userId: string | null
  }

  export type ReplyMaxAggregateOutputType = {
    id: number | null
    content: string | null
    appointmentKey: string | null
    questionContent: string | null
    userId: string | null
  }

  export type ReplyCountAggregateOutputType = {
    id: number
    content: number
    appointmentKey: number
    questionContent: number
    userId: number
    _all: number
  }


  export type ReplyAvgAggregateInputType = {
    id?: true
  }

  export type ReplySumAggregateInputType = {
    id?: true
  }

  export type ReplyMinAggregateInputType = {
    id?: true
    content?: true
    appointmentKey?: true
    questionContent?: true
    userId?: true
  }

  export type ReplyMaxAggregateInputType = {
    id?: true
    content?: true
    appointmentKey?: true
    questionContent?: true
    userId?: true
  }

  export type ReplyCountAggregateInputType = {
    id?: true
    content?: true
    appointmentKey?: true
    questionContent?: true
    userId?: true
    _all?: true
  }

  export type ReplyAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Reply to aggregate.
     */
    where?: ReplyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Replies to fetch.
     */
    orderBy?: ReplyOrderByWithRelationInput | ReplyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ReplyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Replies 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` Replies.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Replies
    **/
    _count?: true | ReplyCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ReplyAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ReplySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ReplyMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ReplyMaxAggregateInputType
  }

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




  export type ReplyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReplyWhereInput
    orderBy?: ReplyOrderByWithAggregationInput | ReplyOrderByWithAggregationInput[]
    by: ReplyScalarFieldEnum[] | ReplyScalarFieldEnum
    having?: ReplyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ReplyCountAggregateInputType | true
    _avg?: ReplyAvgAggregateInputType
    _sum?: ReplySumAggregateInputType
    _min?: ReplyMinAggregateInputType
    _max?: ReplyMaxAggregateInputType
  }

  export type ReplyGroupByOutputType = {
    id: number
    content: string
    appointmentKey: string
    questionContent: string
    userId: string
    _count: ReplyCountAggregateOutputType | null
    _avg: ReplyAvgAggregateOutputType | null
    _sum: ReplySumAggregateOutputType | null
    _min: ReplyMinAggregateOutputType | null
    _max: ReplyMaxAggregateOutputType | null
  }

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


  export type ReplySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    appointmentKey?: boolean
    questionContent?: boolean
    userId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["reply"]>

  export type ReplySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    appointmentKey?: boolean
    questionContent?: boolean
    userId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["reply"]>

  export type ReplySelectScalar = {
    id?: boolean
    content?: boolean
    appointmentKey?: boolean
    questionContent?: boolean
    userId?: boolean
  }

  export type ReplyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ReplyIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ReplyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Reply"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      content: string
      appointmentKey: string
      questionContent: string
      userId: string
    }, ExtArgs["result"]["reply"]>
    composites: {}
  }

  type ReplyGetPayload<S extends boolean | null | undefined | ReplyDefaultArgs> = $Result.GetResult<Prisma.$ReplyPayload, S>

  type ReplyCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ReplyFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ReplyCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Reply 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 {ReplyFindFirstArgs} args - Arguments to find a Reply
     * @example
     * // Get one Reply
     * const reply = await prisma.reply.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ReplyFindFirstArgs>(args?: SelectSubset<T, ReplyFindFirstArgs<ExtArgs>>): Prisma__ReplyClient<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Reply 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 {ReplyFindFirstOrThrowArgs} args - Arguments to find a Reply
     * @example
     * // Get one Reply
     * const reply = await prisma.reply.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ReplyFindFirstOrThrowArgs>(args?: SelectSubset<T, ReplyFindFirstOrThrowArgs<ExtArgs>>): Prisma__ReplyClient<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Replies 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 {ReplyFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Replies
     * const replies = await prisma.reply.findMany()
     * 
     * // Get first 10 Replies
     * const replies = await prisma.reply.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const replyWithIdOnly = await prisma.reply.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ReplyFindManyArgs>(args?: SelectSubset<T, ReplyFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Reply.
     * @param {ReplyCreateArgs} args - Arguments to create a Reply.
     * @example
     * // Create one Reply
     * const Reply = await prisma.reply.create({
     *   data: {
     *     // ... data to create a Reply
     *   }
     * })
     * 
     */
    create<T extends ReplyCreateArgs>(args: SelectSubset<T, ReplyCreateArgs<ExtArgs>>): Prisma__ReplyClient<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Replies and returns the data saved in the database.
     * @param {ReplyCreateManyAndReturnArgs} args - Arguments to create many Replies.
     * @example
     * // Create many Replies
     * const reply = await prisma.reply.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Replies and only return the `id`
     * const replyWithIdOnly = await prisma.reply.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ReplyCreateManyAndReturnArgs>(args?: SelectSubset<T, ReplyCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Reply.
     * @param {ReplyDeleteArgs} args - Arguments to delete one Reply.
     * @example
     * // Delete one Reply
     * const Reply = await prisma.reply.delete({
     *   where: {
     *     // ... filter to delete one Reply
     *   }
     * })
     * 
     */
    delete<T extends ReplyDeleteArgs>(args: SelectSubset<T, ReplyDeleteArgs<ExtArgs>>): Prisma__ReplyClient<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Reply.
     * @param {ReplyUpdateArgs} args - Arguments to update one Reply.
     * @example
     * // Update one Reply
     * const reply = await prisma.reply.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ReplyUpdateArgs>(args: SelectSubset<T, ReplyUpdateArgs<ExtArgs>>): Prisma__ReplyClient<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Reply.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReplyGroupByArgs} 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 ReplyGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ReplyGroupByArgs['orderBy'] }
        : { orderBy?: ReplyGroupByArgs['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, ReplyGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetReplyGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Reply model
   */
  readonly fields: ReplyFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Reply.
   * 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__ReplyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Reply model
   */ 
  interface ReplyFieldRefs {
    readonly id: FieldRef<"Reply", 'Int'>
    readonly content: FieldRef<"Reply", 'String'>
    readonly appointmentKey: FieldRef<"Reply", 'String'>
    readonly questionContent: FieldRef<"Reply", 'String'>
    readonly userId: FieldRef<"Reply", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Reply findUnique
   */
  export type ReplyFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * Filter, which Reply to fetch.
     */
    where: ReplyWhereUniqueInput
  }

  /**
   * Reply findUniqueOrThrow
   */
  export type ReplyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * Filter, which Reply to fetch.
     */
    where: ReplyWhereUniqueInput
  }

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

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

  /**
   * Reply findMany
   */
  export type ReplyFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * Filter, which Replies to fetch.
     */
    where?: ReplyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Replies to fetch.
     */
    orderBy?: ReplyOrderByWithRelationInput | ReplyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Replies.
     */
    cursor?: ReplyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Replies 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` Replies.
     */
    skip?: number
    distinct?: ReplyScalarFieldEnum | ReplyScalarFieldEnum[]
  }

  /**
   * Reply create
   */
  export type ReplyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * The data needed to create a Reply.
     */
    data: XOR<ReplyCreateInput, ReplyUncheckedCreateInput>
  }

  /**
   * Reply createMany
   */
  export type ReplyCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Replies.
     */
    data: ReplyCreateManyInput | ReplyCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Reply createManyAndReturn
   */
  export type ReplyCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Replies.
     */
    data: ReplyCreateManyInput | ReplyCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Reply update
   */
  export type ReplyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * The data needed to update a Reply.
     */
    data: XOR<ReplyUpdateInput, ReplyUncheckedUpdateInput>
    /**
     * Choose, which Reply to update.
     */
    where: ReplyWhereUniqueInput
  }

  /**
   * Reply updateMany
   */
  export type ReplyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Replies.
     */
    data: XOR<ReplyUpdateManyMutationInput, ReplyUncheckedUpdateManyInput>
    /**
     * Filter which Replies to update
     */
    where?: ReplyWhereInput
  }

  /**
   * Reply upsert
   */
  export type ReplyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * The filter to search for the Reply to update in case it exists.
     */
    where: ReplyWhereUniqueInput
    /**
     * In case the Reply found by the `where` argument doesn't exist, create a new Reply with this data.
     */
    create: XOR<ReplyCreateInput, ReplyUncheckedCreateInput>
    /**
     * In case the Reply was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ReplyUpdateInput, ReplyUncheckedUpdateInput>
  }

  /**
   * Reply delete
   */
  export type ReplyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    /**
     * Filter which Reply to delete.
     */
    where: ReplyWhereUniqueInput
  }

  /**
   * Reply deleteMany
   */
  export type ReplyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Replies to delete
     */
    where?: ReplyWhereInput
  }

  /**
   * Reply without action
   */
  export type ReplyDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
  }


  /**
   * Model StripeAccount
   */

  export type AggregateStripeAccount = {
    _count: StripeAccountCountAggregateOutputType | null
    _avg: StripeAccountAvgAggregateOutputType | null
    _sum: StripeAccountSumAggregateOutputType | null
    _min: StripeAccountMinAggregateOutputType | null
    _max: StripeAccountMaxAggregateOutputType | null
  }

  export type StripeAccountAvgAggregateOutputType = {
    id: number | null
  }

  export type StripeAccountSumAggregateOutputType = {
    id: number | null
  }

  export type StripeAccountMinAggregateOutputType = {
    id: number | null
    expertId: string | null
  }

  export type StripeAccountMaxAggregateOutputType = {
    id: number | null
    expertId: string | null
  }

  export type StripeAccountCountAggregateOutputType = {
    id: number
    stripeData: number
    expertId: number
    _all: number
  }


  export type StripeAccountAvgAggregateInputType = {
    id?: true
  }

  export type StripeAccountSumAggregateInputType = {
    id?: true
  }

  export type StripeAccountMinAggregateInputType = {
    id?: true
    expertId?: true
  }

  export type StripeAccountMaxAggregateInputType = {
    id?: true
    expertId?: true
  }

  export type StripeAccountCountAggregateInputType = {
    id?: true
    stripeData?: true
    expertId?: true
    _all?: true
  }

  export type StripeAccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which StripeAccount to aggregate.
     */
    where?: StripeAccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of StripeAccounts to fetch.
     */
    orderBy?: StripeAccountOrderByWithRelationInput | StripeAccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: StripeAccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` StripeAccounts 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` StripeAccounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned StripeAccounts
    **/
    _count?: true | StripeAccountCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: StripeAccountAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: StripeAccountSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: StripeAccountMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: StripeAccountMaxAggregateInputType
  }

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




  export type StripeAccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: StripeAccountWhereInput
    orderBy?: StripeAccountOrderByWithAggregationInput | StripeAccountOrderByWithAggregationInput[]
    by: StripeAccountScalarFieldEnum[] | StripeAccountScalarFieldEnum
    having?: StripeAccountScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: StripeAccountCountAggregateInputType | true
    _avg?: StripeAccountAvgAggregateInputType
    _sum?: StripeAccountSumAggregateInputType
    _min?: StripeAccountMinAggregateInputType
    _max?: StripeAccountMaxAggregateInputType
  }

  export type StripeAccountGroupByOutputType = {
    id: number
    stripeData: JsonValue
    expertId: string
    _count: StripeAccountCountAggregateOutputType | null
    _avg: StripeAccountAvgAggregateOutputType | null
    _sum: StripeAccountSumAggregateOutputType | null
    _min: StripeAccountMinAggregateOutputType | null
    _max: StripeAccountMaxAggregateOutputType | null
  }

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


  export type StripeAccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    stripeData?: boolean
    expertId?: boolean
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["stripeAccount"]>

  export type StripeAccountSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    stripeData?: boolean
    expertId?: boolean
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["stripeAccount"]>

  export type StripeAccountSelectScalar = {
    id?: boolean
    stripeData?: boolean
    expertId?: boolean
  }

  export type StripeAccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }
  export type StripeAccountIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }

  export type $StripeAccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "StripeAccount"
    objects: {
      expert: Prisma.$ExpertPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      stripeData: Prisma.JsonValue
      expertId: string
    }, ExtArgs["result"]["stripeAccount"]>
    composites: {}
  }

  type StripeAccountGetPayload<S extends boolean | null | undefined | StripeAccountDefaultArgs> = $Result.GetResult<Prisma.$StripeAccountPayload, S>

  type StripeAccountCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<StripeAccountFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: StripeAccountCountAggregateInputType | true
    }

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

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

    /**
     * Find the first StripeAccount 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 {StripeAccountFindFirstArgs} args - Arguments to find a StripeAccount
     * @example
     * // Get one StripeAccount
     * const stripeAccount = await prisma.stripeAccount.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends StripeAccountFindFirstArgs>(args?: SelectSubset<T, StripeAccountFindFirstArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first StripeAccount 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 {StripeAccountFindFirstOrThrowArgs} args - Arguments to find a StripeAccount
     * @example
     * // Get one StripeAccount
     * const stripeAccount = await prisma.stripeAccount.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends StripeAccountFindFirstOrThrowArgs>(args?: SelectSubset<T, StripeAccountFindFirstOrThrowArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more StripeAccounts 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 {StripeAccountFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all StripeAccounts
     * const stripeAccounts = await prisma.stripeAccount.findMany()
     * 
     * // Get first 10 StripeAccounts
     * const stripeAccounts = await prisma.stripeAccount.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const stripeAccountWithIdOnly = await prisma.stripeAccount.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends StripeAccountFindManyArgs>(args?: SelectSubset<T, StripeAccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a StripeAccount.
     * @param {StripeAccountCreateArgs} args - Arguments to create a StripeAccount.
     * @example
     * // Create one StripeAccount
     * const StripeAccount = await prisma.stripeAccount.create({
     *   data: {
     *     // ... data to create a StripeAccount
     *   }
     * })
     * 
     */
    create<T extends StripeAccountCreateArgs>(args: SelectSubset<T, StripeAccountCreateArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many StripeAccounts and returns the data saved in the database.
     * @param {StripeAccountCreateManyAndReturnArgs} args - Arguments to create many StripeAccounts.
     * @example
     * // Create many StripeAccounts
     * const stripeAccount = await prisma.stripeAccount.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many StripeAccounts and only return the `id`
     * const stripeAccountWithIdOnly = await prisma.stripeAccount.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends StripeAccountCreateManyAndReturnArgs>(args?: SelectSubset<T, StripeAccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a StripeAccount.
     * @param {StripeAccountDeleteArgs} args - Arguments to delete one StripeAccount.
     * @example
     * // Delete one StripeAccount
     * const StripeAccount = await prisma.stripeAccount.delete({
     *   where: {
     *     // ... filter to delete one StripeAccount
     *   }
     * })
     * 
     */
    delete<T extends StripeAccountDeleteArgs>(args: SelectSubset<T, StripeAccountDeleteArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one StripeAccount.
     * @param {StripeAccountUpdateArgs} args - Arguments to update one StripeAccount.
     * @example
     * // Update one StripeAccount
     * const stripeAccount = await prisma.stripeAccount.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends StripeAccountUpdateArgs>(args: SelectSubset<T, StripeAccountUpdateArgs<ExtArgs>>): Prisma__StripeAccountClient<$Result.GetResult<Prisma.$StripeAccountPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by StripeAccount.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {StripeAccountGroupByArgs} 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 StripeAccountGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: StripeAccountGroupByArgs['orderBy'] }
        : { orderBy?: StripeAccountGroupByArgs['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, StripeAccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetStripeAccountGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the StripeAccount model
   */
  readonly fields: StripeAccountFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for StripeAccount.
   * 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__StripeAccountClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 StripeAccount model
   */ 
  interface StripeAccountFieldRefs {
    readonly id: FieldRef<"StripeAccount", 'Int'>
    readonly stripeData: FieldRef<"StripeAccount", 'Json'>
    readonly expertId: FieldRef<"StripeAccount", 'String'>
  }
    

  // Custom InputTypes
  /**
   * StripeAccount findUnique
   */
  export type StripeAccountFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * Filter, which StripeAccount to fetch.
     */
    where: StripeAccountWhereUniqueInput
  }

  /**
   * StripeAccount findUniqueOrThrow
   */
  export type StripeAccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * Filter, which StripeAccount to fetch.
     */
    where: StripeAccountWhereUniqueInput
  }

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

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

  /**
   * StripeAccount findMany
   */
  export type StripeAccountFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * Filter, which StripeAccounts to fetch.
     */
    where?: StripeAccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of StripeAccounts to fetch.
     */
    orderBy?: StripeAccountOrderByWithRelationInput | StripeAccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing StripeAccounts.
     */
    cursor?: StripeAccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` StripeAccounts 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` StripeAccounts.
     */
    skip?: number
    distinct?: StripeAccountScalarFieldEnum | StripeAccountScalarFieldEnum[]
  }

  /**
   * StripeAccount create
   */
  export type StripeAccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * The data needed to create a StripeAccount.
     */
    data: XOR<StripeAccountCreateInput, StripeAccountUncheckedCreateInput>
  }

  /**
   * StripeAccount createMany
   */
  export type StripeAccountCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many StripeAccounts.
     */
    data: StripeAccountCreateManyInput | StripeAccountCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * StripeAccount createManyAndReturn
   */
  export type StripeAccountCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many StripeAccounts.
     */
    data: StripeAccountCreateManyInput | StripeAccountCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * StripeAccount update
   */
  export type StripeAccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * The data needed to update a StripeAccount.
     */
    data: XOR<StripeAccountUpdateInput, StripeAccountUncheckedUpdateInput>
    /**
     * Choose, which StripeAccount to update.
     */
    where: StripeAccountWhereUniqueInput
  }

  /**
   * StripeAccount updateMany
   */
  export type StripeAccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update StripeAccounts.
     */
    data: XOR<StripeAccountUpdateManyMutationInput, StripeAccountUncheckedUpdateManyInput>
    /**
     * Filter which StripeAccounts to update
     */
    where?: StripeAccountWhereInput
  }

  /**
   * StripeAccount upsert
   */
  export type StripeAccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * The filter to search for the StripeAccount to update in case it exists.
     */
    where: StripeAccountWhereUniqueInput
    /**
     * In case the StripeAccount found by the `where` argument doesn't exist, create a new StripeAccount with this data.
     */
    create: XOR<StripeAccountCreateInput, StripeAccountUncheckedCreateInput>
    /**
     * In case the StripeAccount was found with the provided `where` argument, update it with this data.
     */
    update: XOR<StripeAccountUpdateInput, StripeAccountUncheckedUpdateInput>
  }

  /**
   * StripeAccount delete
   */
  export type StripeAccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
    /**
     * Filter which StripeAccount to delete.
     */
    where: StripeAccountWhereUniqueInput
  }

  /**
   * StripeAccount deleteMany
   */
  export type StripeAccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which StripeAccounts to delete
     */
    where?: StripeAccountWhereInput
  }

  /**
   * StripeAccount without action
   */
  export type StripeAccountDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the StripeAccount
     */
    select?: StripeAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StripeAccountInclude<ExtArgs> | null
  }


  /**
   * Model Key
   */

  export type AggregateKey = {
    _count: KeyCountAggregateOutputType | null
    _min: KeyMinAggregateOutputType | null
    _max: KeyMaxAggregateOutputType | null
  }

  export type KeyMinAggregateOutputType = {
    id: string | null
    hashed_password: string | null
    user_id: string | null
  }

  export type KeyMaxAggregateOutputType = {
    id: string | null
    hashed_password: string | null
    user_id: string | null
  }

  export type KeyCountAggregateOutputType = {
    id: number
    hashed_password: number
    user_id: number
    _all: number
  }


  export type KeyMinAggregateInputType = {
    id?: true
    hashed_password?: true
    user_id?: true
  }

  export type KeyMaxAggregateInputType = {
    id?: true
    hashed_password?: true
    user_id?: true
  }

  export type KeyCountAggregateInputType = {
    id?: true
    hashed_password?: true
    user_id?: true
    _all?: true
  }

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

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




  export type KeyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: KeyWhereInput
    orderBy?: KeyOrderByWithAggregationInput | KeyOrderByWithAggregationInput[]
    by: KeyScalarFieldEnum[] | KeyScalarFieldEnum
    having?: KeyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: KeyCountAggregateInputType | true
    _min?: KeyMinAggregateInputType
    _max?: KeyMaxAggregateInputType
  }

  export type KeyGroupByOutputType = {
    id: string
    hashed_password: string | null
    user_id: string
    _count: KeyCountAggregateOutputType | null
    _min: KeyMinAggregateOutputType | null
    _max: KeyMaxAggregateOutputType | null
  }

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


  export type KeySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    hashed_password?: boolean
    user_id?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["key"]>

  export type KeySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    hashed_password?: boolean
    user_id?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["key"]>

  export type KeySelectScalar = {
    id?: boolean
    hashed_password?: boolean
    user_id?: boolean
  }

  export type KeyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type KeyIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $KeyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Key"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      hashed_password: string | null
      user_id: string
    }, ExtArgs["result"]["key"]>
    composites: {}
  }

  type KeyGetPayload<S extends boolean | null | undefined | KeyDefaultArgs> = $Result.GetResult<Prisma.$KeyPayload, S>

  type KeyCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<KeyFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: KeyCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Key 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 {KeyFindFirstArgs} args - Arguments to find a Key
     * @example
     * // Get one Key
     * const key = await prisma.key.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends KeyFindFirstArgs>(args?: SelectSubset<T, KeyFindFirstArgs<ExtArgs>>): Prisma__KeyClient<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Key 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 {KeyFindFirstOrThrowArgs} args - Arguments to find a Key
     * @example
     * // Get one Key
     * const key = await prisma.key.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends KeyFindFirstOrThrowArgs>(args?: SelectSubset<T, KeyFindFirstOrThrowArgs<ExtArgs>>): Prisma__KeyClient<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Keys 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 {KeyFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Keys
     * const keys = await prisma.key.findMany()
     * 
     * // Get first 10 Keys
     * const keys = await prisma.key.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const keyWithIdOnly = await prisma.key.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends KeyFindManyArgs>(args?: SelectSubset<T, KeyFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Key.
     * @param {KeyCreateArgs} args - Arguments to create a Key.
     * @example
     * // Create one Key
     * const Key = await prisma.key.create({
     *   data: {
     *     // ... data to create a Key
     *   }
     * })
     * 
     */
    create<T extends KeyCreateArgs>(args: SelectSubset<T, KeyCreateArgs<ExtArgs>>): Prisma__KeyClient<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Keys and returns the data saved in the database.
     * @param {KeyCreateManyAndReturnArgs} args - Arguments to create many Keys.
     * @example
     * // Create many Keys
     * const key = await prisma.key.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Keys and only return the `id`
     * const keyWithIdOnly = await prisma.key.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends KeyCreateManyAndReturnArgs>(args?: SelectSubset<T, KeyCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Key.
     * @param {KeyDeleteArgs} args - Arguments to delete one Key.
     * @example
     * // Delete one Key
     * const Key = await prisma.key.delete({
     *   where: {
     *     // ... filter to delete one Key
     *   }
     * })
     * 
     */
    delete<T extends KeyDeleteArgs>(args: SelectSubset<T, KeyDeleteArgs<ExtArgs>>): Prisma__KeyClient<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Key.
     * @param {KeyUpdateArgs} args - Arguments to update one Key.
     * @example
     * // Update one Key
     * const key = await prisma.key.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends KeyUpdateArgs>(args: SelectSubset<T, KeyUpdateArgs<ExtArgs>>): Prisma__KeyClient<$Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Key.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KeyGroupByArgs} 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 KeyGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: KeyGroupByArgs['orderBy'] }
        : { orderBy?: KeyGroupByArgs['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, KeyGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetKeyGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Key model
   */
  readonly fields: KeyFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Key.
   * 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__KeyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Key model
   */ 
  interface KeyFieldRefs {
    readonly id: FieldRef<"Key", 'String'>
    readonly hashed_password: FieldRef<"Key", 'String'>
    readonly user_id: FieldRef<"Key", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Key findUnique
   */
  export type KeyFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * Filter, which Key to fetch.
     */
    where: KeyWhereUniqueInput
  }

  /**
   * Key findUniqueOrThrow
   */
  export type KeyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * Filter, which Key to fetch.
     */
    where: KeyWhereUniqueInput
  }

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

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

  /**
   * Key findMany
   */
  export type KeyFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * Filter, which Keys to fetch.
     */
    where?: KeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Keys to fetch.
     */
    orderBy?: KeyOrderByWithRelationInput | KeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Keys.
     */
    cursor?: KeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Keys 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` Keys.
     */
    skip?: number
    distinct?: KeyScalarFieldEnum | KeyScalarFieldEnum[]
  }

  /**
   * Key create
   */
  export type KeyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * The data needed to create a Key.
     */
    data: XOR<KeyCreateInput, KeyUncheckedCreateInput>
  }

  /**
   * Key createMany
   */
  export type KeyCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Keys.
     */
    data: KeyCreateManyInput | KeyCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Key createManyAndReturn
   */
  export type KeyCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Keys.
     */
    data: KeyCreateManyInput | KeyCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Key update
   */
  export type KeyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * The data needed to update a Key.
     */
    data: XOR<KeyUpdateInput, KeyUncheckedUpdateInput>
    /**
     * Choose, which Key to update.
     */
    where: KeyWhereUniqueInput
  }

  /**
   * Key updateMany
   */
  export type KeyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Keys.
     */
    data: XOR<KeyUpdateManyMutationInput, KeyUncheckedUpdateManyInput>
    /**
     * Filter which Keys to update
     */
    where?: KeyWhereInput
  }

  /**
   * Key upsert
   */
  export type KeyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * The filter to search for the Key to update in case it exists.
     */
    where: KeyWhereUniqueInput
    /**
     * In case the Key found by the `where` argument doesn't exist, create a new Key with this data.
     */
    create: XOR<KeyCreateInput, KeyUncheckedCreateInput>
    /**
     * In case the Key was found with the provided `where` argument, update it with this data.
     */
    update: XOR<KeyUpdateInput, KeyUncheckedUpdateInput>
  }

  /**
   * Key delete
   */
  export type KeyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
    /**
     * Filter which Key to delete.
     */
    where: KeyWhereUniqueInput
  }

  /**
   * Key deleteMany
   */
  export type KeyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Keys to delete
     */
    where?: KeyWhereInput
  }

  /**
   * Key without action
   */
  export type KeyDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Key
     */
    select?: KeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KeyInclude<ExtArgs> | null
  }


  /**
   * Model Experience
   */

  export type AggregateExperience = {
    _count: ExperienceCountAggregateOutputType | null
    _avg: ExperienceAvgAggregateOutputType | null
    _sum: ExperienceSumAggregateOutputType | null
    _min: ExperienceMinAggregateOutputType | null
    _max: ExperienceMaxAggregateOutputType | null
  }

  export type ExperienceAvgAggregateOutputType = {
    id: number | null
  }

  export type ExperienceSumAggregateOutputType = {
    id: number | null
  }

  export type ExperienceMinAggregateOutputType = {
    id: number | null
    companyName: string | null
    role: string | null
    isCurrent: boolean | null
    duration: string | null
    description: string | null
    userId: string | null
    endDate: Date | null
    startDate: Date | null
  }

  export type ExperienceMaxAggregateOutputType = {
    id: number | null
    companyName: string | null
    role: string | null
    isCurrent: boolean | null
    duration: string | null
    description: string | null
    userId: string | null
    endDate: Date | null
    startDate: Date | null
  }

  export type ExperienceCountAggregateOutputType = {
    id: number
    companyName: number
    role: number
    isCurrent: number
    duration: number
    description: number
    userId: number
    endDate: number
    startDate: number
    _all: number
  }


  export type ExperienceAvgAggregateInputType = {
    id?: true
  }

  export type ExperienceSumAggregateInputType = {
    id?: true
  }

  export type ExperienceMinAggregateInputType = {
    id?: true
    companyName?: true
    role?: true
    isCurrent?: true
    duration?: true
    description?: true
    userId?: true
    endDate?: true
    startDate?: true
  }

  export type ExperienceMaxAggregateInputType = {
    id?: true
    companyName?: true
    role?: true
    isCurrent?: true
    duration?: true
    description?: true
    userId?: true
    endDate?: true
    startDate?: true
  }

  export type ExperienceCountAggregateInputType = {
    id?: true
    companyName?: true
    role?: true
    isCurrent?: true
    duration?: true
    description?: true
    userId?: true
    endDate?: true
    startDate?: true
    _all?: true
  }

  export type ExperienceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Experience to aggregate.
     */
    where?: ExperienceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Experiences to fetch.
     */
    orderBy?: ExperienceOrderByWithRelationInput | ExperienceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExperienceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Experiences 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` Experiences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Experiences
    **/
    _count?: true | ExperienceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExperienceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExperienceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExperienceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExperienceMaxAggregateInputType
  }

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




  export type ExperienceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExperienceWhereInput
    orderBy?: ExperienceOrderByWithAggregationInput | ExperienceOrderByWithAggregationInput[]
    by: ExperienceScalarFieldEnum[] | ExperienceScalarFieldEnum
    having?: ExperienceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExperienceCountAggregateInputType | true
    _avg?: ExperienceAvgAggregateInputType
    _sum?: ExperienceSumAggregateInputType
    _min?: ExperienceMinAggregateInputType
    _max?: ExperienceMaxAggregateInputType
  }

  export type ExperienceGroupByOutputType = {
    id: number
    companyName: string
    role: string
    isCurrent: boolean
    duration: string
    description: string
    userId: string
    endDate: Date | null
    startDate: Date | null
    _count: ExperienceCountAggregateOutputType | null
    _avg: ExperienceAvgAggregateOutputType | null
    _sum: ExperienceSumAggregateOutputType | null
    _min: ExperienceMinAggregateOutputType | null
    _max: ExperienceMaxAggregateOutputType | null
  }

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


  export type ExperienceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    companyName?: boolean
    role?: boolean
    isCurrent?: boolean
    duration?: boolean
    description?: boolean
    userId?: boolean
    endDate?: boolean
    startDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["experience"]>

  export type ExperienceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    companyName?: boolean
    role?: boolean
    isCurrent?: boolean
    duration?: boolean
    description?: boolean
    userId?: boolean
    endDate?: boolean
    startDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["experience"]>

  export type ExperienceSelectScalar = {
    id?: boolean
    companyName?: boolean
    role?: boolean
    isCurrent?: boolean
    duration?: boolean
    description?: boolean
    userId?: boolean
    endDate?: boolean
    startDate?: boolean
  }

  export type ExperienceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ExperienceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ExperiencePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Experience"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      companyName: string
      role: string
      isCurrent: boolean
      duration: string
      description: string
      userId: string
      endDate: Date | null
      startDate: Date | null
    }, ExtArgs["result"]["experience"]>
    composites: {}
  }

  type ExperienceGetPayload<S extends boolean | null | undefined | ExperienceDefaultArgs> = $Result.GetResult<Prisma.$ExperiencePayload, S>

  type ExperienceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExperienceFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExperienceCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Experience 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 {ExperienceFindFirstArgs} args - Arguments to find a Experience
     * @example
     * // Get one Experience
     * const experience = await prisma.experience.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExperienceFindFirstArgs>(args?: SelectSubset<T, ExperienceFindFirstArgs<ExtArgs>>): Prisma__ExperienceClient<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Experience 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 {ExperienceFindFirstOrThrowArgs} args - Arguments to find a Experience
     * @example
     * // Get one Experience
     * const experience = await prisma.experience.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExperienceFindFirstOrThrowArgs>(args?: SelectSubset<T, ExperienceFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExperienceClient<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Experiences 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 {ExperienceFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Experiences
     * const experiences = await prisma.experience.findMany()
     * 
     * // Get first 10 Experiences
     * const experiences = await prisma.experience.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const experienceWithIdOnly = await prisma.experience.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExperienceFindManyArgs>(args?: SelectSubset<T, ExperienceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Experience.
     * @param {ExperienceCreateArgs} args - Arguments to create a Experience.
     * @example
     * // Create one Experience
     * const Experience = await prisma.experience.create({
     *   data: {
     *     // ... data to create a Experience
     *   }
     * })
     * 
     */
    create<T extends ExperienceCreateArgs>(args: SelectSubset<T, ExperienceCreateArgs<ExtArgs>>): Prisma__ExperienceClient<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Experiences and returns the data saved in the database.
     * @param {ExperienceCreateManyAndReturnArgs} args - Arguments to create many Experiences.
     * @example
     * // Create many Experiences
     * const experience = await prisma.experience.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Experiences and only return the `id`
     * const experienceWithIdOnly = await prisma.experience.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ExperienceCreateManyAndReturnArgs>(args?: SelectSubset<T, ExperienceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Experience.
     * @param {ExperienceDeleteArgs} args - Arguments to delete one Experience.
     * @example
     * // Delete one Experience
     * const Experience = await prisma.experience.delete({
     *   where: {
     *     // ... filter to delete one Experience
     *   }
     * })
     * 
     */
    delete<T extends ExperienceDeleteArgs>(args: SelectSubset<T, ExperienceDeleteArgs<ExtArgs>>): Prisma__ExperienceClient<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Experience.
     * @param {ExperienceUpdateArgs} args - Arguments to update one Experience.
     * @example
     * // Update one Experience
     * const experience = await prisma.experience.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExperienceUpdateArgs>(args: SelectSubset<T, ExperienceUpdateArgs<ExtArgs>>): Prisma__ExperienceClient<$Result.GetResult<Prisma.$ExperiencePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Experience.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExperienceGroupByArgs} 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 ExperienceGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExperienceGroupByArgs['orderBy'] }
        : { orderBy?: ExperienceGroupByArgs['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, ExperienceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExperienceGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Experience model
   */
  readonly fields: ExperienceFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Experience.
   * 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__ExperienceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Experience model
   */ 
  interface ExperienceFieldRefs {
    readonly id: FieldRef<"Experience", 'Int'>
    readonly companyName: FieldRef<"Experience", 'String'>
    readonly role: FieldRef<"Experience", 'String'>
    readonly isCurrent: FieldRef<"Experience", 'Boolean'>
    readonly duration: FieldRef<"Experience", 'String'>
    readonly description: FieldRef<"Experience", 'String'>
    readonly userId: FieldRef<"Experience", 'String'>
    readonly endDate: FieldRef<"Experience", 'DateTime'>
    readonly startDate: FieldRef<"Experience", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Experience findUnique
   */
  export type ExperienceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * Filter, which Experience to fetch.
     */
    where: ExperienceWhereUniqueInput
  }

  /**
   * Experience findUniqueOrThrow
   */
  export type ExperienceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * Filter, which Experience to fetch.
     */
    where: ExperienceWhereUniqueInput
  }

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

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

  /**
   * Experience findMany
   */
  export type ExperienceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * Filter, which Experiences to fetch.
     */
    where?: ExperienceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Experiences to fetch.
     */
    orderBy?: ExperienceOrderByWithRelationInput | ExperienceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Experiences.
     */
    cursor?: ExperienceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Experiences 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` Experiences.
     */
    skip?: number
    distinct?: ExperienceScalarFieldEnum | ExperienceScalarFieldEnum[]
  }

  /**
   * Experience create
   */
  export type ExperienceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * The data needed to create a Experience.
     */
    data: XOR<ExperienceCreateInput, ExperienceUncheckedCreateInput>
  }

  /**
   * Experience createMany
   */
  export type ExperienceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Experiences.
     */
    data: ExperienceCreateManyInput | ExperienceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Experience createManyAndReturn
   */
  export type ExperienceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Experiences.
     */
    data: ExperienceCreateManyInput | ExperienceCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Experience update
   */
  export type ExperienceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * The data needed to update a Experience.
     */
    data: XOR<ExperienceUpdateInput, ExperienceUncheckedUpdateInput>
    /**
     * Choose, which Experience to update.
     */
    where: ExperienceWhereUniqueInput
  }

  /**
   * Experience updateMany
   */
  export type ExperienceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Experiences.
     */
    data: XOR<ExperienceUpdateManyMutationInput, ExperienceUncheckedUpdateManyInput>
    /**
     * Filter which Experiences to update
     */
    where?: ExperienceWhereInput
  }

  /**
   * Experience upsert
   */
  export type ExperienceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * The filter to search for the Experience to update in case it exists.
     */
    where: ExperienceWhereUniqueInput
    /**
     * In case the Experience found by the `where` argument doesn't exist, create a new Experience with this data.
     */
    create: XOR<ExperienceCreateInput, ExperienceUncheckedCreateInput>
    /**
     * In case the Experience was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExperienceUpdateInput, ExperienceUncheckedUpdateInput>
  }

  /**
   * Experience delete
   */
  export type ExperienceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
    /**
     * Filter which Experience to delete.
     */
    where: ExperienceWhereUniqueInput
  }

  /**
   * Experience deleteMany
   */
  export type ExperienceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Experiences to delete
     */
    where?: ExperienceWhereInput
  }

  /**
   * Experience without action
   */
  export type ExperienceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Experience
     */
    select?: ExperienceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExperienceInclude<ExtArgs> | null
  }


  /**
   * Model Education
   */

  export type AggregateEducation = {
    _count: EducationCountAggregateOutputType | null
    _avg: EducationAvgAggregateOutputType | null
    _sum: EducationSumAggregateOutputType | null
    _min: EducationMinAggregateOutputType | null
    _max: EducationMaxAggregateOutputType | null
  }

  export type EducationAvgAggregateOutputType = {
    id: number | null
  }

  export type EducationSumAggregateOutputType = {
    id: number | null
  }

  export type EducationMinAggregateOutputType = {
    id: number | null
    institutionName: string | null
    diplomaTitle: string | null
    fieldOfStudy: string | null
    isCurrent: boolean | null
    duration: string | null
    userId: string | null
    startDate: Date | null
    endDate: Date | null
  }

  export type EducationMaxAggregateOutputType = {
    id: number | null
    institutionName: string | null
    diplomaTitle: string | null
    fieldOfStudy: string | null
    isCurrent: boolean | null
    duration: string | null
    userId: string | null
    startDate: Date | null
    endDate: Date | null
  }

  export type EducationCountAggregateOutputType = {
    id: number
    institutionName: number
    diplomaTitle: number
    fieldOfStudy: number
    isCurrent: number
    duration: number
    userId: number
    startDate: number
    endDate: number
    _all: number
  }


  export type EducationAvgAggregateInputType = {
    id?: true
  }

  export type EducationSumAggregateInputType = {
    id?: true
  }

  export type EducationMinAggregateInputType = {
    id?: true
    institutionName?: true
    diplomaTitle?: true
    fieldOfStudy?: true
    isCurrent?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
  }

  export type EducationMaxAggregateInputType = {
    id?: true
    institutionName?: true
    diplomaTitle?: true
    fieldOfStudy?: true
    isCurrent?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
  }

  export type EducationCountAggregateInputType = {
    id?: true
    institutionName?: true
    diplomaTitle?: true
    fieldOfStudy?: true
    isCurrent?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
    _all?: true
  }

  export type EducationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Education to aggregate.
     */
    where?: EducationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Educations to fetch.
     */
    orderBy?: EducationOrderByWithRelationInput | EducationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: EducationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Educations 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` Educations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Educations
    **/
    _count?: true | EducationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: EducationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: EducationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: EducationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: EducationMaxAggregateInputType
  }

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




  export type EducationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EducationWhereInput
    orderBy?: EducationOrderByWithAggregationInput | EducationOrderByWithAggregationInput[]
    by: EducationScalarFieldEnum[] | EducationScalarFieldEnum
    having?: EducationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EducationCountAggregateInputType | true
    _avg?: EducationAvgAggregateInputType
    _sum?: EducationSumAggregateInputType
    _min?: EducationMinAggregateInputType
    _max?: EducationMaxAggregateInputType
  }

  export type EducationGroupByOutputType = {
    id: number
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent: boolean
    duration: string
    userId: string
    startDate: Date | null
    endDate: Date | null
    _count: EducationCountAggregateOutputType | null
    _avg: EducationAvgAggregateOutputType | null
    _sum: EducationSumAggregateOutputType | null
    _min: EducationMinAggregateOutputType | null
    _max: EducationMaxAggregateOutputType | null
  }

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


  export type EducationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    institutionName?: boolean
    diplomaTitle?: boolean
    fieldOfStudy?: boolean
    isCurrent?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["education"]>

  export type EducationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    institutionName?: boolean
    diplomaTitle?: boolean
    fieldOfStudy?: boolean
    isCurrent?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["education"]>

  export type EducationSelectScalar = {
    id?: boolean
    institutionName?: boolean
    diplomaTitle?: boolean
    fieldOfStudy?: boolean
    isCurrent?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
  }

  export type EducationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type EducationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $EducationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Education"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      institutionName: string
      diplomaTitle: string
      fieldOfStudy: string
      isCurrent: boolean
      duration: string
      userId: string
      startDate: Date | null
      endDate: Date | null
    }, ExtArgs["result"]["education"]>
    composites: {}
  }

  type EducationGetPayload<S extends boolean | null | undefined | EducationDefaultArgs> = $Result.GetResult<Prisma.$EducationPayload, S>

  type EducationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<EducationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: EducationCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Education 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 {EducationFindFirstArgs} args - Arguments to find a Education
     * @example
     * // Get one Education
     * const education = await prisma.education.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends EducationFindFirstArgs>(args?: SelectSubset<T, EducationFindFirstArgs<ExtArgs>>): Prisma__EducationClient<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Education 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 {EducationFindFirstOrThrowArgs} args - Arguments to find a Education
     * @example
     * // Get one Education
     * const education = await prisma.education.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends EducationFindFirstOrThrowArgs>(args?: SelectSubset<T, EducationFindFirstOrThrowArgs<ExtArgs>>): Prisma__EducationClient<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Educations 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 {EducationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Educations
     * const educations = await prisma.education.findMany()
     * 
     * // Get first 10 Educations
     * const educations = await prisma.education.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const educationWithIdOnly = await prisma.education.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends EducationFindManyArgs>(args?: SelectSubset<T, EducationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Education.
     * @param {EducationCreateArgs} args - Arguments to create a Education.
     * @example
     * // Create one Education
     * const Education = await prisma.education.create({
     *   data: {
     *     // ... data to create a Education
     *   }
     * })
     * 
     */
    create<T extends EducationCreateArgs>(args: SelectSubset<T, EducationCreateArgs<ExtArgs>>): Prisma__EducationClient<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Educations and returns the data saved in the database.
     * @param {EducationCreateManyAndReturnArgs} args - Arguments to create many Educations.
     * @example
     * // Create many Educations
     * const education = await prisma.education.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Educations and only return the `id`
     * const educationWithIdOnly = await prisma.education.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends EducationCreateManyAndReturnArgs>(args?: SelectSubset<T, EducationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Education.
     * @param {EducationDeleteArgs} args - Arguments to delete one Education.
     * @example
     * // Delete one Education
     * const Education = await prisma.education.delete({
     *   where: {
     *     // ... filter to delete one Education
     *   }
     * })
     * 
     */
    delete<T extends EducationDeleteArgs>(args: SelectSubset<T, EducationDeleteArgs<ExtArgs>>): Prisma__EducationClient<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Education.
     * @param {EducationUpdateArgs} args - Arguments to update one Education.
     * @example
     * // Update one Education
     * const education = await prisma.education.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends EducationUpdateArgs>(args: SelectSubset<T, EducationUpdateArgs<ExtArgs>>): Prisma__EducationClient<$Result.GetResult<Prisma.$EducationPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Education.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {EducationGroupByArgs} 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 EducationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: EducationGroupByArgs['orderBy'] }
        : { orderBy?: EducationGroupByArgs['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, EducationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEducationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Education model
   */
  readonly fields: EducationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Education.
   * 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__EducationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Education model
   */ 
  interface EducationFieldRefs {
    readonly id: FieldRef<"Education", 'Int'>
    readonly institutionName: FieldRef<"Education", 'String'>
    readonly diplomaTitle: FieldRef<"Education", 'String'>
    readonly fieldOfStudy: FieldRef<"Education", 'String'>
    readonly isCurrent: FieldRef<"Education", 'Boolean'>
    readonly duration: FieldRef<"Education", 'String'>
    readonly userId: FieldRef<"Education", 'String'>
    readonly startDate: FieldRef<"Education", 'DateTime'>
    readonly endDate: FieldRef<"Education", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Education findUnique
   */
  export type EducationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * Filter, which Education to fetch.
     */
    where: EducationWhereUniqueInput
  }

  /**
   * Education findUniqueOrThrow
   */
  export type EducationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * Filter, which Education to fetch.
     */
    where: EducationWhereUniqueInput
  }

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

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

  /**
   * Education findMany
   */
  export type EducationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * Filter, which Educations to fetch.
     */
    where?: EducationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Educations to fetch.
     */
    orderBy?: EducationOrderByWithRelationInput | EducationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Educations.
     */
    cursor?: EducationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Educations 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` Educations.
     */
    skip?: number
    distinct?: EducationScalarFieldEnum | EducationScalarFieldEnum[]
  }

  /**
   * Education create
   */
  export type EducationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * The data needed to create a Education.
     */
    data: XOR<EducationCreateInput, EducationUncheckedCreateInput>
  }

  /**
   * Education createMany
   */
  export type EducationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Educations.
     */
    data: EducationCreateManyInput | EducationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Education createManyAndReturn
   */
  export type EducationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Educations.
     */
    data: EducationCreateManyInput | EducationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Education update
   */
  export type EducationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * The data needed to update a Education.
     */
    data: XOR<EducationUpdateInput, EducationUncheckedUpdateInput>
    /**
     * Choose, which Education to update.
     */
    where: EducationWhereUniqueInput
  }

  /**
   * Education updateMany
   */
  export type EducationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Educations.
     */
    data: XOR<EducationUpdateManyMutationInput, EducationUncheckedUpdateManyInput>
    /**
     * Filter which Educations to update
     */
    where?: EducationWhereInput
  }

  /**
   * Education upsert
   */
  export type EducationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * The filter to search for the Education to update in case it exists.
     */
    where: EducationWhereUniqueInput
    /**
     * In case the Education found by the `where` argument doesn't exist, create a new Education with this data.
     */
    create: XOR<EducationCreateInput, EducationUncheckedCreateInput>
    /**
     * In case the Education was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EducationUpdateInput, EducationUncheckedUpdateInput>
  }

  /**
   * Education delete
   */
  export type EducationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
    /**
     * Filter which Education to delete.
     */
    where: EducationWhereUniqueInput
  }

  /**
   * Education deleteMany
   */
  export type EducationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Educations to delete
     */
    where?: EducationWhereInput
  }

  /**
   * Education without action
   */
  export type EducationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Education
     */
    select?: EducationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EducationInclude<ExtArgs> | null
  }


  /**
   * Model Expertise
   */

  export type AggregateExpertise = {
    _count: ExpertiseCountAggregateOutputType | null
    _avg: ExpertiseAvgAggregateOutputType | null
    _sum: ExpertiseSumAggregateOutputType | null
    _min: ExpertiseMinAggregateOutputType | null
    _max: ExpertiseMaxAggregateOutputType | null
  }

  export type ExpertiseAvgAggregateOutputType = {
    id: number | null
  }

  export type ExpertiseSumAggregateOutputType = {
    id: number | null
  }

  export type ExpertiseMinAggregateOutputType = {
    id: number | null
    field: string | null
    isCurrent: boolean | null
    description: string | null
    duration: string | null
    userId: string | null
    startDate: Date | null
    endDate: Date | null
  }

  export type ExpertiseMaxAggregateOutputType = {
    id: number | null
    field: string | null
    isCurrent: boolean | null
    description: string | null
    duration: string | null
    userId: string | null
    startDate: Date | null
    endDate: Date | null
  }

  export type ExpertiseCountAggregateOutputType = {
    id: number
    field: number
    isCurrent: number
    description: number
    duration: number
    userId: number
    startDate: number
    endDate: number
    _all: number
  }


  export type ExpertiseAvgAggregateInputType = {
    id?: true
  }

  export type ExpertiseSumAggregateInputType = {
    id?: true
  }

  export type ExpertiseMinAggregateInputType = {
    id?: true
    field?: true
    isCurrent?: true
    description?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
  }

  export type ExpertiseMaxAggregateInputType = {
    id?: true
    field?: true
    isCurrent?: true
    description?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
  }

  export type ExpertiseCountAggregateInputType = {
    id?: true
    field?: true
    isCurrent?: true
    description?: true
    duration?: true
    userId?: true
    startDate?: true
    endDate?: true
    _all?: true
  }

  export type ExpertiseAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Expertise to aggregate.
     */
    where?: ExpertiseWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Expertise to fetch.
     */
    orderBy?: ExpertiseOrderByWithRelationInput | ExpertiseOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExpertiseWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Expertise 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` Expertise.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Expertise
    **/
    _count?: true | ExpertiseCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExpertiseAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExpertiseSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExpertiseMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExpertiseMaxAggregateInputType
  }

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




  export type ExpertiseGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExpertiseWhereInput
    orderBy?: ExpertiseOrderByWithAggregationInput | ExpertiseOrderByWithAggregationInput[]
    by: ExpertiseScalarFieldEnum[] | ExpertiseScalarFieldEnum
    having?: ExpertiseScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertiseCountAggregateInputType | true
    _avg?: ExpertiseAvgAggregateInputType
    _sum?: ExpertiseSumAggregateInputType
    _min?: ExpertiseMinAggregateInputType
    _max?: ExpertiseMaxAggregateInputType
  }

  export type ExpertiseGroupByOutputType = {
    id: number
    field: string
    isCurrent: boolean
    description: string
    duration: string
    userId: string
    startDate: Date | null
    endDate: Date | null
    _count: ExpertiseCountAggregateOutputType | null
    _avg: ExpertiseAvgAggregateOutputType | null
    _sum: ExpertiseSumAggregateOutputType | null
    _min: ExpertiseMinAggregateOutputType | null
    _max: ExpertiseMaxAggregateOutputType | null
  }

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


  export type ExpertiseSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    field?: boolean
    isCurrent?: boolean
    description?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertise"]>

  export type ExpertiseSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    field?: boolean
    isCurrent?: boolean
    description?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertise"]>

  export type ExpertiseSelectScalar = {
    id?: boolean
    field?: boolean
    isCurrent?: boolean
    description?: boolean
    duration?: boolean
    userId?: boolean
    startDate?: boolean
    endDate?: boolean
  }

  export type ExpertiseInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ExpertiseIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ExpertisePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Expertise"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      field: string
      isCurrent: boolean
      description: string
      duration: string
      userId: string
      startDate: Date | null
      endDate: Date | null
    }, ExtArgs["result"]["expertise"]>
    composites: {}
  }

  type ExpertiseGetPayload<S extends boolean | null | undefined | ExpertiseDefaultArgs> = $Result.GetResult<Prisma.$ExpertisePayload, S>

  type ExpertiseCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExpertiseFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExpertiseCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Expertise 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 {ExpertiseFindFirstArgs} args - Arguments to find a Expertise
     * @example
     * // Get one Expertise
     * const expertise = await prisma.expertise.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExpertiseFindFirstArgs>(args?: SelectSubset<T, ExpertiseFindFirstArgs<ExtArgs>>): Prisma__ExpertiseClient<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Expertise 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 {ExpertiseFindFirstOrThrowArgs} args - Arguments to find a Expertise
     * @example
     * // Get one Expertise
     * const expertise = await prisma.expertise.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExpertiseFindFirstOrThrowArgs>(args?: SelectSubset<T, ExpertiseFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExpertiseClient<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Expertise 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 {ExpertiseFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Expertise
     * const expertise = await prisma.expertise.findMany()
     * 
     * // Get first 10 Expertise
     * const expertise = await prisma.expertise.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const expertiseWithIdOnly = await prisma.expertise.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExpertiseFindManyArgs>(args?: SelectSubset<T, ExpertiseFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Expertise.
     * @param {ExpertiseCreateArgs} args - Arguments to create a Expertise.
     * @example
     * // Create one Expertise
     * const Expertise = await prisma.expertise.create({
     *   data: {
     *     // ... data to create a Expertise
     *   }
     * })
     * 
     */
    create<T extends ExpertiseCreateArgs>(args: SelectSubset<T, ExpertiseCreateArgs<ExtArgs>>): Prisma__ExpertiseClient<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Expertise and returns the data saved in the database.
     * @param {ExpertiseCreateManyAndReturnArgs} args - Arguments to create many Expertise.
     * @example
     * // Create many Expertise
     * const expertise = await prisma.expertise.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Expertise and only return the `id`
     * const expertiseWithIdOnly = await prisma.expertise.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ExpertiseCreateManyAndReturnArgs>(args?: SelectSubset<T, ExpertiseCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Expertise.
     * @param {ExpertiseDeleteArgs} args - Arguments to delete one Expertise.
     * @example
     * // Delete one Expertise
     * const Expertise = await prisma.expertise.delete({
     *   where: {
     *     // ... filter to delete one Expertise
     *   }
     * })
     * 
     */
    delete<T extends ExpertiseDeleteArgs>(args: SelectSubset<T, ExpertiseDeleteArgs<ExtArgs>>): Prisma__ExpertiseClient<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Expertise.
     * @param {ExpertiseUpdateArgs} args - Arguments to update one Expertise.
     * @example
     * // Update one Expertise
     * const expertise = await prisma.expertise.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExpertiseUpdateArgs>(args: SelectSubset<T, ExpertiseUpdateArgs<ExtArgs>>): Prisma__ExpertiseClient<$Result.GetResult<Prisma.$ExpertisePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Expertise.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExpertiseGroupByArgs} 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 ExpertiseGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExpertiseGroupByArgs['orderBy'] }
        : { orderBy?: ExpertiseGroupByArgs['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, ExpertiseGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExpertiseGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Expertise model
   */
  readonly fields: ExpertiseFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Expertise.
   * 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__ExpertiseClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Expertise model
   */ 
  interface ExpertiseFieldRefs {
    readonly id: FieldRef<"Expertise", 'Int'>
    readonly field: FieldRef<"Expertise", 'String'>
    readonly isCurrent: FieldRef<"Expertise", 'Boolean'>
    readonly description: FieldRef<"Expertise", 'String'>
    readonly duration: FieldRef<"Expertise", 'String'>
    readonly userId: FieldRef<"Expertise", 'String'>
    readonly startDate: FieldRef<"Expertise", 'DateTime'>
    readonly endDate: FieldRef<"Expertise", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Expertise findUnique
   */
  export type ExpertiseFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * Filter, which Expertise to fetch.
     */
    where: ExpertiseWhereUniqueInput
  }

  /**
   * Expertise findUniqueOrThrow
   */
  export type ExpertiseFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * Filter, which Expertise to fetch.
     */
    where: ExpertiseWhereUniqueInput
  }

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

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

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

  /**
   * Expertise create
   */
  export type ExpertiseCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * The data needed to create a Expertise.
     */
    data: XOR<ExpertiseCreateInput, ExpertiseUncheckedCreateInput>
  }

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

  /**
   * Expertise createManyAndReturn
   */
  export type ExpertiseCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Expertise.
     */
    data: ExpertiseCreateManyInput | ExpertiseCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Expertise update
   */
  export type ExpertiseUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * The data needed to update a Expertise.
     */
    data: XOR<ExpertiseUpdateInput, ExpertiseUncheckedUpdateInput>
    /**
     * Choose, which Expertise to update.
     */
    where: ExpertiseWhereUniqueInput
  }

  /**
   * Expertise updateMany
   */
  export type ExpertiseUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Expertise.
     */
    data: XOR<ExpertiseUpdateManyMutationInput, ExpertiseUncheckedUpdateManyInput>
    /**
     * Filter which Expertise to update
     */
    where?: ExpertiseWhereInput
  }

  /**
   * Expertise upsert
   */
  export type ExpertiseUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * The filter to search for the Expertise to update in case it exists.
     */
    where: ExpertiseWhereUniqueInput
    /**
     * In case the Expertise found by the `where` argument doesn't exist, create a new Expertise with this data.
     */
    create: XOR<ExpertiseCreateInput, ExpertiseUncheckedCreateInput>
    /**
     * In case the Expertise was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExpertiseUpdateInput, ExpertiseUncheckedUpdateInput>
  }

  /**
   * Expertise delete
   */
  export type ExpertiseDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
    /**
     * Filter which Expertise to delete.
     */
    where: ExpertiseWhereUniqueInput
  }

  /**
   * Expertise deleteMany
   */
  export type ExpertiseDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Expertise to delete
     */
    where?: ExpertiseWhereInput
  }

  /**
   * Expertise without action
   */
  export type ExpertiseDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expertise
     */
    select?: ExpertiseSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertiseInclude<ExtArgs> | null
  }


  /**
   * Model Language
   */

  export type AggregateLanguage = {
    _count: LanguageCountAggregateOutputType | null
    _avg: LanguageAvgAggregateOutputType | null
    _sum: LanguageSumAggregateOutputType | null
    _min: LanguageMinAggregateOutputType | null
    _max: LanguageMaxAggregateOutputType | null
  }

  export type LanguageAvgAggregateOutputType = {
    id: number | null
  }

  export type LanguageSumAggregateOutputType = {
    id: number | null
  }

  export type LanguageMinAggregateOutputType = {
    id: number | null
    name: string | null
    userId: string | null
  }

  export type LanguageMaxAggregateOutputType = {
    id: number | null
    name: string | null
    userId: string | null
  }

  export type LanguageCountAggregateOutputType = {
    id: number
    name: number
    userId: number
    _all: number
  }


  export type LanguageAvgAggregateInputType = {
    id?: true
  }

  export type LanguageSumAggregateInputType = {
    id?: true
  }

  export type LanguageMinAggregateInputType = {
    id?: true
    name?: true
    userId?: true
  }

  export type LanguageMaxAggregateInputType = {
    id?: true
    name?: true
    userId?: true
  }

  export type LanguageCountAggregateInputType = {
    id?: true
    name?: true
    userId?: true
    _all?: true
  }

  export type LanguageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Language to aggregate.
     */
    where?: LanguageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Languages to fetch.
     */
    orderBy?: LanguageOrderByWithRelationInput | LanguageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: LanguageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Languages 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` Languages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Languages
    **/
    _count?: true | LanguageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: LanguageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: LanguageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LanguageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LanguageMaxAggregateInputType
  }

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




  export type LanguageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LanguageWhereInput
    orderBy?: LanguageOrderByWithAggregationInput | LanguageOrderByWithAggregationInput[]
    by: LanguageScalarFieldEnum[] | LanguageScalarFieldEnum
    having?: LanguageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LanguageCountAggregateInputType | true
    _avg?: LanguageAvgAggregateInputType
    _sum?: LanguageSumAggregateInputType
    _min?: LanguageMinAggregateInputType
    _max?: LanguageMaxAggregateInputType
  }

  export type LanguageGroupByOutputType = {
    id: number
    name: string
    userId: string
    _count: LanguageCountAggregateOutputType | null
    _avg: LanguageAvgAggregateOutputType | null
    _sum: LanguageSumAggregateOutputType | null
    _min: LanguageMinAggregateOutputType | null
    _max: LanguageMaxAggregateOutputType | null
  }

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


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

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

  export type LanguageSelectScalar = {
    id?: boolean
    name?: boolean
    userId?: boolean
  }

  export type LanguageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type LanguageIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $LanguagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Language"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      userId: string
    }, ExtArgs["result"]["language"]>
    composites: {}
  }

  type LanguageGetPayload<S extends boolean | null | undefined | LanguageDefaultArgs> = $Result.GetResult<Prisma.$LanguagePayload, S>

  type LanguageCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<LanguageFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: LanguageCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Language 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 {LanguageFindFirstArgs} args - Arguments to find a Language
     * @example
     * // Get one Language
     * const language = await prisma.language.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends LanguageFindFirstArgs>(args?: SelectSubset<T, LanguageFindFirstArgs<ExtArgs>>): Prisma__LanguageClient<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Language 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 {LanguageFindFirstOrThrowArgs} args - Arguments to find a Language
     * @example
     * // Get one Language
     * const language = await prisma.language.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends LanguageFindFirstOrThrowArgs>(args?: SelectSubset<T, LanguageFindFirstOrThrowArgs<ExtArgs>>): Prisma__LanguageClient<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Languages 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 {LanguageFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Languages
     * const languages = await prisma.language.findMany()
     * 
     * // Get first 10 Languages
     * const languages = await prisma.language.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const languageWithIdOnly = await prisma.language.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends LanguageFindManyArgs>(args?: SelectSubset<T, LanguageFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Language.
     * @param {LanguageCreateArgs} args - Arguments to create a Language.
     * @example
     * // Create one Language
     * const Language = await prisma.language.create({
     *   data: {
     *     // ... data to create a Language
     *   }
     * })
     * 
     */
    create<T extends LanguageCreateArgs>(args: SelectSubset<T, LanguageCreateArgs<ExtArgs>>): Prisma__LanguageClient<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Languages and returns the data saved in the database.
     * @param {LanguageCreateManyAndReturnArgs} args - Arguments to create many Languages.
     * @example
     * // Create many Languages
     * const language = await prisma.language.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Languages and only return the `id`
     * const languageWithIdOnly = await prisma.language.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends LanguageCreateManyAndReturnArgs>(args?: SelectSubset<T, LanguageCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Language.
     * @param {LanguageDeleteArgs} args - Arguments to delete one Language.
     * @example
     * // Delete one Language
     * const Language = await prisma.language.delete({
     *   where: {
     *     // ... filter to delete one Language
     *   }
     * })
     * 
     */
    delete<T extends LanguageDeleteArgs>(args: SelectSubset<T, LanguageDeleteArgs<ExtArgs>>): Prisma__LanguageClient<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Language.
     * @param {LanguageUpdateArgs} args - Arguments to update one Language.
     * @example
     * // Update one Language
     * const language = await prisma.language.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LanguageUpdateArgs>(args: SelectSubset<T, LanguageUpdateArgs<ExtArgs>>): Prisma__LanguageClient<$Result.GetResult<Prisma.$LanguagePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Language.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LanguageGroupByArgs} 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 LanguageGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: LanguageGroupByArgs['orderBy'] }
        : { orderBy?: LanguageGroupByArgs['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, LanguageGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLanguageGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Language model
   */
  readonly fields: LanguageFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Language.
   * 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__LanguageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 Language model
   */ 
  interface LanguageFieldRefs {
    readonly id: FieldRef<"Language", 'Int'>
    readonly name: FieldRef<"Language", 'String'>
    readonly userId: FieldRef<"Language", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Language findUnique
   */
  export type LanguageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * Filter, which Language to fetch.
     */
    where: LanguageWhereUniqueInput
  }

  /**
   * Language findUniqueOrThrow
   */
  export type LanguageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * Filter, which Language to fetch.
     */
    where: LanguageWhereUniqueInput
  }

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

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

  /**
   * Language findMany
   */
  export type LanguageFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * Filter, which Languages to fetch.
     */
    where?: LanguageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Languages to fetch.
     */
    orderBy?: LanguageOrderByWithRelationInput | LanguageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Languages.
     */
    cursor?: LanguageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Languages 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` Languages.
     */
    skip?: number
    distinct?: LanguageScalarFieldEnum | LanguageScalarFieldEnum[]
  }

  /**
   * Language create
   */
  export type LanguageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * The data needed to create a Language.
     */
    data: XOR<LanguageCreateInput, LanguageUncheckedCreateInput>
  }

  /**
   * Language createMany
   */
  export type LanguageCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Languages.
     */
    data: LanguageCreateManyInput | LanguageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Language createManyAndReturn
   */
  export type LanguageCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Languages.
     */
    data: LanguageCreateManyInput | LanguageCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Language update
   */
  export type LanguageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * The data needed to update a Language.
     */
    data: XOR<LanguageUpdateInput, LanguageUncheckedUpdateInput>
    /**
     * Choose, which Language to update.
     */
    where: LanguageWhereUniqueInput
  }

  /**
   * Language updateMany
   */
  export type LanguageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Languages.
     */
    data: XOR<LanguageUpdateManyMutationInput, LanguageUncheckedUpdateManyInput>
    /**
     * Filter which Languages to update
     */
    where?: LanguageWhereInput
  }

  /**
   * Language upsert
   */
  export type LanguageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * The filter to search for the Language to update in case it exists.
     */
    where: LanguageWhereUniqueInput
    /**
     * In case the Language found by the `where` argument doesn't exist, create a new Language with this data.
     */
    create: XOR<LanguageCreateInput, LanguageUncheckedCreateInput>
    /**
     * In case the Language was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LanguageUpdateInput, LanguageUncheckedUpdateInput>
  }

  /**
   * Language delete
   */
  export type LanguageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
    /**
     * Filter which Language to delete.
     */
    where: LanguageWhereUniqueInput
  }

  /**
   * Language deleteMany
   */
  export type LanguageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Languages to delete
     */
    where?: LanguageWhereInput
  }

  /**
   * Language without action
   */
  export type LanguageDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Language
     */
    select?: LanguageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LanguageInclude<ExtArgs> | null
  }


  /**
   * Model Appointment
   */

  export type AggregateAppointment = {
    _count: AppointmentCountAggregateOutputType | null
    _avg: AppointmentAvgAggregateOutputType | null
    _sum: AppointmentSumAggregateOutputType | null
    _min: AppointmentMinAggregateOutputType | null
    _max: AppointmentMaxAggregateOutputType | null
  }

  export type AppointmentAvgAggregateOutputType = {
    id: number | null
    date: number | null
  }

  export type AppointmentSumAggregateOutputType = {
    id: number | null
    date: number | null
  }

  export type AppointmentMinAggregateOutputType = {
    id: number | null
    clientId: string | null
    clientEmail: string | null
    expertId: string | null
    clientName: string | null
    expertName: string | null
    isAcceptedByExpert: string | null
    price: string | null
    timezone: string | null
    date: number | null
    dayName: string | null
    time: string | null
    text: string | null
    createdAt: Date | null
    videoRoomId: string | null
    appointmentKey: string | null
    paymentStatus: string | null
    paymentIntentId: string | null
    sessionId: string | null
    authorizedDate: string | null
    appointementKeyInExpertTimeZone: string | null
    appointementKeyInClientTimeZone: string | null
    status: string | null
    reason: string | null
  }

  export type AppointmentMaxAggregateOutputType = {
    id: number | null
    clientId: string | null
    clientEmail: string | null
    expertId: string | null
    clientName: string | null
    expertName: string | null
    isAcceptedByExpert: string | null
    price: string | null
    timezone: string | null
    date: number | null
    dayName: string | null
    time: string | null
    text: string | null
    createdAt: Date | null
    videoRoomId: string | null
    appointmentKey: string | null
    paymentStatus: string | null
    paymentIntentId: string | null
    sessionId: string | null
    authorizedDate: string | null
    appointementKeyInExpertTimeZone: string | null
    appointementKeyInClientTimeZone: string | null
    status: string | null
    reason: string | null
  }

  export type AppointmentCountAggregateOutputType = {
    id: number
    clientId: number
    clientEmail: number
    expertId: number
    clientName: number
    expertName: number
    isAcceptedByExpert: number
    price: number
    timezone: number
    date: number
    dayName: number
    time: number
    text: number
    createdAt: number
    videoRoomId: number
    appointmentKey: number
    paymentStatus: number
    paymentIntentId: number
    sessionId: number
    authorizedDate: number
    appointementKeyInExpertTimeZone: number
    appointementKeyInClientTimeZone: number
    bookedAppointments: number
    status: number
    reason: number
    _all: number
  }


  export type AppointmentAvgAggregateInputType = {
    id?: true
    date?: true
  }

  export type AppointmentSumAggregateInputType = {
    id?: true
    date?: true
  }

  export type AppointmentMinAggregateInputType = {
    id?: true
    clientId?: true
    clientEmail?: true
    expertId?: true
    clientName?: true
    expertName?: true
    isAcceptedByExpert?: true
    price?: true
    timezone?: true
    date?: true
    dayName?: true
    time?: true
    text?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    paymentStatus?: true
    paymentIntentId?: true
    sessionId?: true
    authorizedDate?: true
    appointementKeyInExpertTimeZone?: true
    appointementKeyInClientTimeZone?: true
    status?: true
    reason?: true
  }

  export type AppointmentMaxAggregateInputType = {
    id?: true
    clientId?: true
    clientEmail?: true
    expertId?: true
    clientName?: true
    expertName?: true
    isAcceptedByExpert?: true
    price?: true
    timezone?: true
    date?: true
    dayName?: true
    time?: true
    text?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    paymentStatus?: true
    paymentIntentId?: true
    sessionId?: true
    authorizedDate?: true
    appointementKeyInExpertTimeZone?: true
    appointementKeyInClientTimeZone?: true
    status?: true
    reason?: true
  }

  export type AppointmentCountAggregateInputType = {
    id?: true
    clientId?: true
    clientEmail?: true
    expertId?: true
    clientName?: true
    expertName?: true
    isAcceptedByExpert?: true
    price?: true
    timezone?: true
    date?: true
    dayName?: true
    time?: true
    text?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    paymentStatus?: true
    paymentIntentId?: true
    sessionId?: true
    authorizedDate?: true
    appointementKeyInExpertTimeZone?: true
    appointementKeyInClientTimeZone?: true
    bookedAppointments?: true
    status?: true
    reason?: 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 average
    **/
    _avg?: AppointmentAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AppointmentSumAggregateInputType
    /**
     * {@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
    _avg?: AppointmentAvgAggregateInputType
    _sum?: AppointmentSumAggregateInputType
    _min?: AppointmentMinAggregateInputType
    _max?: AppointmentMaxAggregateInputType
  }

  export type AppointmentGroupByOutputType = {
    id: number
    clientId: string
    clientEmail: string
    expertId: string
    clientName: string
    expertName: string
    isAcceptedByExpert: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text: string | null
    createdAt: Date
    videoRoomId: string
    appointmentKey: string
    paymentStatus: string
    paymentIntentId: string
    sessionId: string
    authorizedDate: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments: JsonValue | null
    status: string
    reason: string | null
    _count: AppointmentCountAggregateOutputType | null
    _avg: AppointmentAvgAggregateOutputType | null
    _sum: AppointmentSumAggregateOutputType | 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
    clientId?: boolean
    clientEmail?: boolean
    expertId?: boolean
    clientName?: boolean
    expertName?: boolean
    isAcceptedByExpert?: boolean
    price?: boolean
    timezone?: boolean
    date?: boolean
    dayName?: boolean
    time?: boolean
    text?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    paymentStatus?: boolean
    paymentIntentId?: boolean
    sessionId?: boolean
    authorizedDate?: boolean
    appointementKeyInExpertTimeZone?: boolean
    appointementKeyInClientTimeZone?: boolean
    bookedAppointments?: boolean
    status?: boolean
    reason?: boolean
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    receivedClientReviews?: boolean | Appointment$receivedClientReviewsArgs<ExtArgs>
    writtenExpertReviews?: boolean | Appointment$writtenExpertReviewsArgs<ExtArgs>
    reply?: boolean | Appointment$replyArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    clientId?: boolean
    clientEmail?: boolean
    expertId?: boolean
    clientName?: boolean
    expertName?: boolean
    isAcceptedByExpert?: boolean
    price?: boolean
    timezone?: boolean
    date?: boolean
    dayName?: boolean
    time?: boolean
    text?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    paymentStatus?: boolean
    paymentIntentId?: boolean
    sessionId?: boolean
    authorizedDate?: boolean
    appointementKeyInExpertTimeZone?: boolean
    appointementKeyInClientTimeZone?: boolean
    bookedAppointments?: boolean
    status?: boolean
    reason?: boolean
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectScalar = {
    id?: boolean
    clientId?: boolean
    clientEmail?: boolean
    expertId?: boolean
    clientName?: boolean
    expertName?: boolean
    isAcceptedByExpert?: boolean
    price?: boolean
    timezone?: boolean
    date?: boolean
    dayName?: boolean
    time?: boolean
    text?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    paymentStatus?: boolean
    paymentIntentId?: boolean
    sessionId?: boolean
    authorizedDate?: boolean
    appointementKeyInExpertTimeZone?: boolean
    appointementKeyInClientTimeZone?: boolean
    bookedAppointments?: boolean
    status?: boolean
    reason?: boolean
  }

  export type AppointmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    receivedClientReviews?: boolean | Appointment$receivedClientReviewsArgs<ExtArgs>
    writtenExpertReviews?: boolean | Appointment$writtenExpertReviewsArgs<ExtArgs>
    reply?: boolean | Appointment$replyArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type AppointmentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }

  export type $AppointmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Appointment"
    objects: {
      client: Prisma.$UserPayload<ExtArgs>
      expert: Prisma.$ExpertPayload<ExtArgs>
      receivedClientReviews: Prisma.$ClientReviewPayload<ExtArgs> | null
      writtenExpertReviews: Prisma.$ExpertReviewPayload<ExtArgs> | null
      reply: Prisma.$ReplyPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      clientId: string
      clientEmail: string
      expertId: string
      clientName: string
      expertName: string
      isAcceptedByExpert: string
      price: string
      timezone: string
      date: number
      dayName: string
      time: string
      text: string | null
      createdAt: Date
      videoRoomId: string
      appointmentKey: string
      paymentStatus: string
      paymentIntentId: string
      sessionId: string
      authorizedDate: string
      appointementKeyInExpertTimeZone: string
      appointementKeyInClientTimeZone: string
      bookedAppointments: Prisma.JsonValue | null
      status: string
      reason: string | null
    }, 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'> & {
      select?: AppointmentCountAggregateInputType | true
    }

  export interface AppointmentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

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

    /**
     * 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">, never, ExtArgs>

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

    /**
     * Create many Appointments and returns the data saved in the database.
     * @param {AppointmentCreateManyAndReturnArgs} args - Arguments to create many Appointments.
     * @example
     * // Create many Appointments
     * const appointment = await prisma.appointment.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Appointments and only return the `id`
     * const appointmentWithIdOnly = await prisma.appointment.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AppointmentCreateManyAndReturnArgs>(args?: SelectSubset<T, AppointmentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>


    /**
     * 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> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    client<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    receivedClientReviews<T extends Appointment$receivedClientReviewsArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$receivedClientReviewsArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    writtenExpertReviews<T extends Appointment$writtenExpertReviewsArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$writtenExpertReviewsArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    reply<T extends Appointment$replyArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$replyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReplyPayload<ExtArgs>, T, "findMany"> | 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 Appointment model
   */ 
  interface AppointmentFieldRefs {
    readonly id: FieldRef<"Appointment", 'Int'>
    readonly clientId: FieldRef<"Appointment", 'String'>
    readonly clientEmail: FieldRef<"Appointment", 'String'>
    readonly expertId: FieldRef<"Appointment", 'String'>
    readonly clientName: FieldRef<"Appointment", 'String'>
    readonly expertName: FieldRef<"Appointment", 'String'>
    readonly isAcceptedByExpert: FieldRef<"Appointment", 'String'>
    readonly price: FieldRef<"Appointment", 'String'>
    readonly timezone: FieldRef<"Appointment", 'String'>
    readonly date: FieldRef<"Appointment", 'Int'>
    readonly dayName: FieldRef<"Appointment", 'String'>
    readonly time: FieldRef<"Appointment", 'String'>
    readonly text: FieldRef<"Appointment", 'String'>
    readonly createdAt: FieldRef<"Appointment", 'DateTime'>
    readonly videoRoomId: FieldRef<"Appointment", 'String'>
    readonly appointmentKey: FieldRef<"Appointment", 'String'>
    readonly paymentStatus: FieldRef<"Appointment", 'String'>
    readonly paymentIntentId: FieldRef<"Appointment", 'String'>
    readonly sessionId: FieldRef<"Appointment", 'String'>
    readonly authorizedDate: FieldRef<"Appointment", 'String'>
    readonly appointementKeyInExpertTimeZone: FieldRef<"Appointment", 'String'>
    readonly appointementKeyInClientTimeZone: FieldRef<"Appointment", 'String'>
    readonly bookedAppointments: FieldRef<"Appointment", 'Json'>
    readonly status: FieldRef<"Appointment", 'String'>
    readonly reason: FieldRef<"Appointment", 'String'>
  }
    

  // 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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 createManyAndReturn
   */
  export type AppointmentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Appointments.
     */
    data: AppointmentCreateManyInput | AppointmentCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Appointment update
   */
  export type AppointmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<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
  }

  /**
   * Appointment upsert
   */
  export type AppointmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<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
    /**
     * 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
  }

  /**
   * Appointment.receivedClientReviews
   */
  export type Appointment$receivedClientReviewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    where?: ClientReviewWhereInput
  }

  /**
   * Appointment.writtenExpertReviews
   */
  export type Appointment$writtenExpertReviewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    where?: ExpertReviewWhereInput
  }

  /**
   * Appointment.reply
   */
  export type Appointment$replyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Reply
     */
    select?: ReplySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReplyInclude<ExtArgs> | null
    where?: ReplyWhereInput
    orderBy?: ReplyOrderByWithRelationInput | ReplyOrderByWithRelationInput[]
    cursor?: ReplyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ReplyScalarFieldEnum | ReplyScalarFieldEnum[]
  }

  /**
   * Appointment without action
   */
  export type AppointmentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
  }


  /**
   * Model Availability
   */

  export type AggregateAvailability = {
    _count: AvailabilityCountAggregateOutputType | null
    _avg: AvailabilityAvgAggregateOutputType | null
    _sum: AvailabilitySumAggregateOutputType | null
    _min: AvailabilityMinAggregateOutputType | null
    _max: AvailabilityMaxAggregateOutputType | null
  }

  export type AvailabilityAvgAggregateOutputType = {
    id: number | null
  }

  export type AvailabilitySumAggregateOutputType = {
    id: number | null
  }

  export type AvailabilityMinAggregateOutputType = {
    id: number | null
    day: string | null
    timezone: string | null
    expertId: string | null
    userId: string | null
  }

  export type AvailabilityMaxAggregateOutputType = {
    id: number | null
    day: string | null
    timezone: string | null
    expertId: string | null
    userId: string | null
  }

  export type AvailabilityCountAggregateOutputType = {
    id: number
    day: number
    timezone: number
    expertId: number
    userId: number
    _all: number
  }


  export type AvailabilityAvgAggregateInputType = {
    id?: true
  }

  export type AvailabilitySumAggregateInputType = {
    id?: true
  }

  export type AvailabilityMinAggregateInputType = {
    id?: true
    day?: true
    timezone?: true
    expertId?: true
    userId?: true
  }

  export type AvailabilityMaxAggregateInputType = {
    id?: true
    day?: true
    timezone?: true
    expertId?: true
    userId?: true
  }

  export type AvailabilityCountAggregateInputType = {
    id?: true
    day?: true
    timezone?: true
    expertId?: true
    userId?: true
    _all?: true
  }

  export type AvailabilityAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Availability to aggregate.
     */
    where?: AvailabilityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Availabilities to fetch.
     */
    orderBy?: AvailabilityOrderByWithRelationInput | AvailabilityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AvailabilityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Availabilities 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` Availabilities.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Availabilities
    **/
    _count?: true | AvailabilityCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AvailabilityAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AvailabilitySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AvailabilityMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AvailabilityMaxAggregateInputType
  }

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




  export type AvailabilityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AvailabilityWhereInput
    orderBy?: AvailabilityOrderByWithAggregationInput | AvailabilityOrderByWithAggregationInput[]
    by: AvailabilityScalarFieldEnum[] | AvailabilityScalarFieldEnum
    having?: AvailabilityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AvailabilityCountAggregateInputType | true
    _avg?: AvailabilityAvgAggregateInputType
    _sum?: AvailabilitySumAggregateInputType
    _min?: AvailabilityMinAggregateInputType
    _max?: AvailabilityMaxAggregateInputType
  }

  export type AvailabilityGroupByOutputType = {
    id: number
    day: string
    timezone: string
    expertId: string
    userId: string | null
    _count: AvailabilityCountAggregateOutputType | null
    _avg: AvailabilityAvgAggregateOutputType | null
    _sum: AvailabilitySumAggregateOutputType | null
    _min: AvailabilityMinAggregateOutputType | null
    _max: AvailabilityMaxAggregateOutputType | null
  }

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


  export type AvailabilitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    day?: boolean
    timezone?: boolean
    expertId?: boolean
    userId?: boolean
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    user?: boolean | Availability$userArgs<ExtArgs>
    slots?: boolean | Availability$slotsArgs<ExtArgs>
    _count?: boolean | AvailabilityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["availability"]>

  export type AvailabilitySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    day?: boolean
    timezone?: boolean
    expertId?: boolean
    userId?: boolean
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    user?: boolean | Availability$userArgs<ExtArgs>
  }, ExtArgs["result"]["availability"]>

  export type AvailabilitySelectScalar = {
    id?: boolean
    day?: boolean
    timezone?: boolean
    expertId?: boolean
    userId?: boolean
  }

  export type AvailabilityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    user?: boolean | Availability$userArgs<ExtArgs>
    slots?: boolean | Availability$slotsArgs<ExtArgs>
    _count?: boolean | AvailabilityCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type AvailabilityIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    user?: boolean | Availability$userArgs<ExtArgs>
  }

  export type $AvailabilityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Availability"
    objects: {
      expert: Prisma.$ExpertPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs> | null
      slots: Prisma.$SlotPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      day: string
      timezone: string
      expertId: string
      userId: string | null
    }, ExtArgs["result"]["availability"]>
    composites: {}
  }

  type AvailabilityGetPayload<S extends boolean | null | undefined | AvailabilityDefaultArgs> = $Result.GetResult<Prisma.$AvailabilityPayload, S>

  type AvailabilityCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AvailabilityFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: AvailabilityCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Availability 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 {AvailabilityFindFirstArgs} args - Arguments to find a Availability
     * @example
     * // Get one Availability
     * const availability = await prisma.availability.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AvailabilityFindFirstArgs>(args?: SelectSubset<T, AvailabilityFindFirstArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Availability 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 {AvailabilityFindFirstOrThrowArgs} args - Arguments to find a Availability
     * @example
     * // Get one Availability
     * const availability = await prisma.availability.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AvailabilityFindFirstOrThrowArgs>(args?: SelectSubset<T, AvailabilityFindFirstOrThrowArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Availabilities 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 {AvailabilityFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Availabilities
     * const availabilities = await prisma.availability.findMany()
     * 
     * // Get first 10 Availabilities
     * const availabilities = await prisma.availability.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const availabilityWithIdOnly = await prisma.availability.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends AvailabilityFindManyArgs>(args?: SelectSubset<T, AvailabilityFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Availability.
     * @param {AvailabilityCreateArgs} args - Arguments to create a Availability.
     * @example
     * // Create one Availability
     * const Availability = await prisma.availability.create({
     *   data: {
     *     // ... data to create a Availability
     *   }
     * })
     * 
     */
    create<T extends AvailabilityCreateArgs>(args: SelectSubset<T, AvailabilityCreateArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Availabilities and returns the data saved in the database.
     * @param {AvailabilityCreateManyAndReturnArgs} args - Arguments to create many Availabilities.
     * @example
     * // Create many Availabilities
     * const availability = await prisma.availability.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Availabilities and only return the `id`
     * const availabilityWithIdOnly = await prisma.availability.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AvailabilityCreateManyAndReturnArgs>(args?: SelectSubset<T, AvailabilityCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Availability.
     * @param {AvailabilityDeleteArgs} args - Arguments to delete one Availability.
     * @example
     * // Delete one Availability
     * const Availability = await prisma.availability.delete({
     *   where: {
     *     // ... filter to delete one Availability
     *   }
     * })
     * 
     */
    delete<T extends AvailabilityDeleteArgs>(args: SelectSubset<T, AvailabilityDeleteArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Availability.
     * @param {AvailabilityUpdateArgs} args - Arguments to update one Availability.
     * @example
     * // Update one Availability
     * const availability = await prisma.availability.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AvailabilityUpdateArgs>(args: SelectSubset<T, AvailabilityUpdateArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Availability.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AvailabilityGroupByArgs} 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 AvailabilityGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AvailabilityGroupByArgs['orderBy'] }
        : { orderBy?: AvailabilityGroupByArgs['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, AvailabilityGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAvailabilityGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Availability model
   */
  readonly fields: AvailabilityFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Availability.
   * 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__AvailabilityClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    user<T extends Availability$userArgs<ExtArgs> = {}>(args?: Subset<T, Availability$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    slots<T extends Availability$slotsArgs<ExtArgs> = {}>(args?: Subset<T, Availability$slotsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "findMany"> | 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 Availability model
   */ 
  interface AvailabilityFieldRefs {
    readonly id: FieldRef<"Availability", 'Int'>
    readonly day: FieldRef<"Availability", 'String'>
    readonly timezone: FieldRef<"Availability", 'String'>
    readonly expertId: FieldRef<"Availability", 'String'>
    readonly userId: FieldRef<"Availability", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Availability findUnique
   */
  export type AvailabilityFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * Filter, which Availability to fetch.
     */
    where: AvailabilityWhereUniqueInput
  }

  /**
   * Availability findUniqueOrThrow
   */
  export type AvailabilityFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * Filter, which Availability to fetch.
     */
    where: AvailabilityWhereUniqueInput
  }

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

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

  /**
   * Availability findMany
   */
  export type AvailabilityFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * Filter, which Availabilities to fetch.
     */
    where?: AvailabilityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Availabilities to fetch.
     */
    orderBy?: AvailabilityOrderByWithRelationInput | AvailabilityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Availabilities.
     */
    cursor?: AvailabilityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Availabilities 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` Availabilities.
     */
    skip?: number
    distinct?: AvailabilityScalarFieldEnum | AvailabilityScalarFieldEnum[]
  }

  /**
   * Availability create
   */
  export type AvailabilityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * The data needed to create a Availability.
     */
    data: XOR<AvailabilityCreateInput, AvailabilityUncheckedCreateInput>
  }

  /**
   * Availability createMany
   */
  export type AvailabilityCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Availabilities.
     */
    data: AvailabilityCreateManyInput | AvailabilityCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Availability createManyAndReturn
   */
  export type AvailabilityCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Availabilities.
     */
    data: AvailabilityCreateManyInput | AvailabilityCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Availability update
   */
  export type AvailabilityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * The data needed to update a Availability.
     */
    data: XOR<AvailabilityUpdateInput, AvailabilityUncheckedUpdateInput>
    /**
     * Choose, which Availability to update.
     */
    where: AvailabilityWhereUniqueInput
  }

  /**
   * Availability updateMany
   */
  export type AvailabilityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Availabilities.
     */
    data: XOR<AvailabilityUpdateManyMutationInput, AvailabilityUncheckedUpdateManyInput>
    /**
     * Filter which Availabilities to update
     */
    where?: AvailabilityWhereInput
  }

  /**
   * Availability upsert
   */
  export type AvailabilityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * The filter to search for the Availability to update in case it exists.
     */
    where: AvailabilityWhereUniqueInput
    /**
     * In case the Availability found by the `where` argument doesn't exist, create a new Availability with this data.
     */
    create: XOR<AvailabilityCreateInput, AvailabilityUncheckedCreateInput>
    /**
     * In case the Availability was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AvailabilityUpdateInput, AvailabilityUncheckedUpdateInput>
  }

  /**
   * Availability delete
   */
  export type AvailabilityDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
    /**
     * Filter which Availability to delete.
     */
    where: AvailabilityWhereUniqueInput
  }

  /**
   * Availability deleteMany
   */
  export type AvailabilityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Availabilities to delete
     */
    where?: AvailabilityWhereInput
  }

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

  /**
   * Availability.slots
   */
  export type Availability$slotsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    where?: SlotWhereInput
    orderBy?: SlotOrderByWithRelationInput | SlotOrderByWithRelationInput[]
    cursor?: SlotWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SlotScalarFieldEnum | SlotScalarFieldEnum[]
  }

  /**
   * Availability without action
   */
  export type AvailabilityDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Availability
     */
    select?: AvailabilitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AvailabilityInclude<ExtArgs> | null
  }


  /**
   * Model Slot
   */

  export type AggregateSlot = {
    _count: SlotCountAggregateOutputType | null
    _avg: SlotAvgAggregateOutputType | null
    _sum: SlotSumAggregateOutputType | null
    _min: SlotMinAggregateOutputType | null
    _max: SlotMaxAggregateOutputType | null
  }

  export type SlotAvgAggregateOutputType = {
    availabilityId: number | null
  }

  export type SlotSumAggregateOutputType = {
    availabilityId: number | null
  }

  export type SlotMinAggregateOutputType = {
    id: string | null
    start: string | null
    end: string | null
    recurring: boolean | null
    availabilityId: number | null
    hide: boolean | null
    isSplit: boolean | null
    originalId: string | null
  }

  export type SlotMaxAggregateOutputType = {
    id: string | null
    start: string | null
    end: string | null
    recurring: boolean | null
    availabilityId: number | null
    hide: boolean | null
    isSplit: boolean | null
    originalId: string | null
  }

  export type SlotCountAggregateOutputType = {
    id: number
    start: number
    end: number
    recurring: number
    availabilityId: number
    hide: number
    isSplit: number
    originalId: number
    _all: number
  }


  export type SlotAvgAggregateInputType = {
    availabilityId?: true
  }

  export type SlotSumAggregateInputType = {
    availabilityId?: true
  }

  export type SlotMinAggregateInputType = {
    id?: true
    start?: true
    end?: true
    recurring?: true
    availabilityId?: true
    hide?: true
    isSplit?: true
    originalId?: true
  }

  export type SlotMaxAggregateInputType = {
    id?: true
    start?: true
    end?: true
    recurring?: true
    availabilityId?: true
    hide?: true
    isSplit?: true
    originalId?: true
  }

  export type SlotCountAggregateInputType = {
    id?: true
    start?: true
    end?: true
    recurring?: true
    availabilityId?: true
    hide?: true
    isSplit?: true
    originalId?: true
    _all?: true
  }

  export type SlotAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Slot to aggregate.
     */
    where?: SlotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Slots to fetch.
     */
    orderBy?: SlotOrderByWithRelationInput | SlotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SlotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Slots 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` Slots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Slots
    **/
    _count?: true | SlotCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SlotAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SlotSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SlotMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SlotMaxAggregateInputType
  }

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




  export type SlotGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SlotWhereInput
    orderBy?: SlotOrderByWithAggregationInput | SlotOrderByWithAggregationInput[]
    by: SlotScalarFieldEnum[] | SlotScalarFieldEnum
    having?: SlotScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SlotCountAggregateInputType | true
    _avg?: SlotAvgAggregateInputType
    _sum?: SlotSumAggregateInputType
    _min?: SlotMinAggregateInputType
    _max?: SlotMaxAggregateInputType
  }

  export type SlotGroupByOutputType = {
    id: string
    start: string
    end: string
    recurring: boolean
    availabilityId: number
    hide: boolean
    isSplit: boolean
    originalId: string
    _count: SlotCountAggregateOutputType | null
    _avg: SlotAvgAggregateOutputType | null
    _sum: SlotSumAggregateOutputType | null
    _min: SlotMinAggregateOutputType | null
    _max: SlotMaxAggregateOutputType | null
  }

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


  export type SlotSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    start?: boolean
    end?: boolean
    recurring?: boolean
    availabilityId?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId?: boolean
    exceptions?: boolean | Slot$exceptionsArgs<ExtArgs>
    Availability?: boolean | AvailabilityDefaultArgs<ExtArgs>
    _count?: boolean | SlotCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["slot"]>

  export type SlotSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    start?: boolean
    end?: boolean
    recurring?: boolean
    availabilityId?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId?: boolean
    Availability?: boolean | AvailabilityDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["slot"]>

  export type SlotSelectScalar = {
    id?: boolean
    start?: boolean
    end?: boolean
    recurring?: boolean
    availabilityId?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId?: boolean
  }

  export type SlotInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    exceptions?: boolean | Slot$exceptionsArgs<ExtArgs>
    Availability?: boolean | AvailabilityDefaultArgs<ExtArgs>
    _count?: boolean | SlotCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type SlotIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Availability?: boolean | AvailabilityDefaultArgs<ExtArgs>
  }

  export type $SlotPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Slot"
    objects: {
      exceptions: Prisma.$ExceptionPayload<ExtArgs>[]
      Availability: Prisma.$AvailabilityPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      start: string
      end: string
      recurring: boolean
      availabilityId: number
      hide: boolean
      isSplit: boolean
      originalId: string
    }, ExtArgs["result"]["slot"]>
    composites: {}
  }

  type SlotGetPayload<S extends boolean | null | undefined | SlotDefaultArgs> = $Result.GetResult<Prisma.$SlotPayload, S>

  type SlotCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SlotFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SlotCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Slot 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 {SlotFindFirstArgs} args - Arguments to find a Slot
     * @example
     * // Get one Slot
     * const slot = await prisma.slot.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SlotFindFirstArgs>(args?: SelectSubset<T, SlotFindFirstArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Slot 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 {SlotFindFirstOrThrowArgs} args - Arguments to find a Slot
     * @example
     * // Get one Slot
     * const slot = await prisma.slot.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SlotFindFirstOrThrowArgs>(args?: SelectSubset<T, SlotFindFirstOrThrowArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Slots 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 {SlotFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Slots
     * const slots = await prisma.slot.findMany()
     * 
     * // Get first 10 Slots
     * const slots = await prisma.slot.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const slotWithIdOnly = await prisma.slot.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends SlotFindManyArgs>(args?: SelectSubset<T, SlotFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Slot.
     * @param {SlotCreateArgs} args - Arguments to create a Slot.
     * @example
     * // Create one Slot
     * const Slot = await prisma.slot.create({
     *   data: {
     *     // ... data to create a Slot
     *   }
     * })
     * 
     */
    create<T extends SlotCreateArgs>(args: SelectSubset<T, SlotCreateArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Slots and returns the data saved in the database.
     * @param {SlotCreateManyAndReturnArgs} args - Arguments to create many Slots.
     * @example
     * // Create many Slots
     * const slot = await prisma.slot.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Slots and only return the `id`
     * const slotWithIdOnly = await prisma.slot.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SlotCreateManyAndReturnArgs>(args?: SelectSubset<T, SlotCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Slot.
     * @param {SlotDeleteArgs} args - Arguments to delete one Slot.
     * @example
     * // Delete one Slot
     * const Slot = await prisma.slot.delete({
     *   where: {
     *     // ... filter to delete one Slot
     *   }
     * })
     * 
     */
    delete<T extends SlotDeleteArgs>(args: SelectSubset<T, SlotDeleteArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Slot.
     * @param {SlotUpdateArgs} args - Arguments to update one Slot.
     * @example
     * // Update one Slot
     * const slot = await prisma.slot.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SlotUpdateArgs>(args: SelectSubset<T, SlotUpdateArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Slot.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SlotGroupByArgs} 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 SlotGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SlotGroupByArgs['orderBy'] }
        : { orderBy?: SlotGroupByArgs['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, SlotGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSlotGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Slot model
   */
  readonly fields: SlotFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Slot.
   * 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__SlotClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    exceptions<T extends Slot$exceptionsArgs<ExtArgs> = {}>(args?: Subset<T, Slot$exceptionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "findMany"> | Null>
    Availability<T extends AvailabilityDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AvailabilityDefaultArgs<ExtArgs>>): Prisma__AvailabilityClient<$Result.GetResult<Prisma.$AvailabilityPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Slot model
   */ 
  interface SlotFieldRefs {
    readonly id: FieldRef<"Slot", 'String'>
    readonly start: FieldRef<"Slot", 'String'>
    readonly end: FieldRef<"Slot", 'String'>
    readonly recurring: FieldRef<"Slot", 'Boolean'>
    readonly availabilityId: FieldRef<"Slot", 'Int'>
    readonly hide: FieldRef<"Slot", 'Boolean'>
    readonly isSplit: FieldRef<"Slot", 'Boolean'>
    readonly originalId: FieldRef<"Slot", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Slot findUnique
   */
  export type SlotFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * Filter, which Slot to fetch.
     */
    where: SlotWhereUniqueInput
  }

  /**
   * Slot findUniqueOrThrow
   */
  export type SlotFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * Filter, which Slot to fetch.
     */
    where: SlotWhereUniqueInput
  }

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

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

  /**
   * Slot findMany
   */
  export type SlotFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * Filter, which Slots to fetch.
     */
    where?: SlotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Slots to fetch.
     */
    orderBy?: SlotOrderByWithRelationInput | SlotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Slots.
     */
    cursor?: SlotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Slots 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` Slots.
     */
    skip?: number
    distinct?: SlotScalarFieldEnum | SlotScalarFieldEnum[]
  }

  /**
   * Slot create
   */
  export type SlotCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * The data needed to create a Slot.
     */
    data: XOR<SlotCreateInput, SlotUncheckedCreateInput>
  }

  /**
   * Slot createMany
   */
  export type SlotCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Slots.
     */
    data: SlotCreateManyInput | SlotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Slot createManyAndReturn
   */
  export type SlotCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Slots.
     */
    data: SlotCreateManyInput | SlotCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Slot update
   */
  export type SlotUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * The data needed to update a Slot.
     */
    data: XOR<SlotUpdateInput, SlotUncheckedUpdateInput>
    /**
     * Choose, which Slot to update.
     */
    where: SlotWhereUniqueInput
  }

  /**
   * Slot updateMany
   */
  export type SlotUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Slots.
     */
    data: XOR<SlotUpdateManyMutationInput, SlotUncheckedUpdateManyInput>
    /**
     * Filter which Slots to update
     */
    where?: SlotWhereInput
  }

  /**
   * Slot upsert
   */
  export type SlotUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * The filter to search for the Slot to update in case it exists.
     */
    where: SlotWhereUniqueInput
    /**
     * In case the Slot found by the `where` argument doesn't exist, create a new Slot with this data.
     */
    create: XOR<SlotCreateInput, SlotUncheckedCreateInput>
    /**
     * In case the Slot was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SlotUpdateInput, SlotUncheckedUpdateInput>
  }

  /**
   * Slot delete
   */
  export type SlotDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
    /**
     * Filter which Slot to delete.
     */
    where: SlotWhereUniqueInput
  }

  /**
   * Slot deleteMany
   */
  export type SlotDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Slots to delete
     */
    where?: SlotWhereInput
  }

  /**
   * Slot.exceptions
   */
  export type Slot$exceptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    where?: ExceptionWhereInput
    orderBy?: ExceptionOrderByWithRelationInput | ExceptionOrderByWithRelationInput[]
    cursor?: ExceptionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExceptionScalarFieldEnum | ExceptionScalarFieldEnum[]
  }

  /**
   * Slot without action
   */
  export type SlotDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Slot
     */
    select?: SlotSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SlotInclude<ExtArgs> | null
  }


  /**
   * Model Exception
   */

  export type AggregateException = {
    _count: ExceptionCountAggregateOutputType | null
    _avg: ExceptionAvgAggregateOutputType | null
    _sum: ExceptionSumAggregateOutputType | null
    _min: ExceptionMinAggregateOutputType | null
    _max: ExceptionMaxAggregateOutputType | null
  }

  export type ExceptionAvgAggregateOutputType = {
    id: number | null
  }

  export type ExceptionSumAggregateOutputType = {
    id: number | null
  }

  export type ExceptionMinAggregateOutputType = {
    id: number | null
    date: string | null
    slotId: string | null
  }

  export type ExceptionMaxAggregateOutputType = {
    id: number | null
    date: string | null
    slotId: string | null
  }

  export type ExceptionCountAggregateOutputType = {
    id: number
    date: number
    slotId: number
    _all: number
  }


  export type ExceptionAvgAggregateInputType = {
    id?: true
  }

  export type ExceptionSumAggregateInputType = {
    id?: true
  }

  export type ExceptionMinAggregateInputType = {
    id?: true
    date?: true
    slotId?: true
  }

  export type ExceptionMaxAggregateInputType = {
    id?: true
    date?: true
    slotId?: true
  }

  export type ExceptionCountAggregateInputType = {
    id?: true
    date?: true
    slotId?: true
    _all?: true
  }

  export type ExceptionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Exception to aggregate.
     */
    where?: ExceptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exceptions to fetch.
     */
    orderBy?: ExceptionOrderByWithRelationInput | ExceptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExceptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exceptions 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` Exceptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Exceptions
    **/
    _count?: true | ExceptionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExceptionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExceptionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExceptionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExceptionMaxAggregateInputType
  }

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




  export type ExceptionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExceptionWhereInput
    orderBy?: ExceptionOrderByWithAggregationInput | ExceptionOrderByWithAggregationInput[]
    by: ExceptionScalarFieldEnum[] | ExceptionScalarFieldEnum
    having?: ExceptionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExceptionCountAggregateInputType | true
    _avg?: ExceptionAvgAggregateInputType
    _sum?: ExceptionSumAggregateInputType
    _min?: ExceptionMinAggregateInputType
    _max?: ExceptionMaxAggregateInputType
  }

  export type ExceptionGroupByOutputType = {
    id: number
    date: string
    slotId: string
    _count: ExceptionCountAggregateOutputType | null
    _avg: ExceptionAvgAggregateOutputType | null
    _sum: ExceptionSumAggregateOutputType | null
    _min: ExceptionMinAggregateOutputType | null
    _max: ExceptionMaxAggregateOutputType | null
  }

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


  export type ExceptionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    slotId?: boolean
    Slot?: boolean | SlotDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["exception"]>

  export type ExceptionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    slotId?: boolean
    Slot?: boolean | SlotDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["exception"]>

  export type ExceptionSelectScalar = {
    id?: boolean
    date?: boolean
    slotId?: boolean
  }

  export type ExceptionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Slot?: boolean | SlotDefaultArgs<ExtArgs>
  }
  export type ExceptionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Slot?: boolean | SlotDefaultArgs<ExtArgs>
  }

  export type $ExceptionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Exception"
    objects: {
      Slot: Prisma.$SlotPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      date: string
      slotId: string
    }, ExtArgs["result"]["exception"]>
    composites: {}
  }

  type ExceptionGetPayload<S extends boolean | null | undefined | ExceptionDefaultArgs> = $Result.GetResult<Prisma.$ExceptionPayload, S>

  type ExceptionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExceptionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExceptionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Exception 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 {ExceptionFindFirstArgs} args - Arguments to find a Exception
     * @example
     * // Get one Exception
     * const exception = await prisma.exception.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExceptionFindFirstArgs>(args?: SelectSubset<T, ExceptionFindFirstArgs<ExtArgs>>): Prisma__ExceptionClient<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Exception 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 {ExceptionFindFirstOrThrowArgs} args - Arguments to find a Exception
     * @example
     * // Get one Exception
     * const exception = await prisma.exception.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExceptionFindFirstOrThrowArgs>(args?: SelectSubset<T, ExceptionFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExceptionClient<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Exceptions 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 {ExceptionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Exceptions
     * const exceptions = await prisma.exception.findMany()
     * 
     * // Get first 10 Exceptions
     * const exceptions = await prisma.exception.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const exceptionWithIdOnly = await prisma.exception.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExceptionFindManyArgs>(args?: SelectSubset<T, ExceptionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Exception.
     * @param {ExceptionCreateArgs} args - Arguments to create a Exception.
     * @example
     * // Create one Exception
     * const Exception = await prisma.exception.create({
     *   data: {
     *     // ... data to create a Exception
     *   }
     * })
     * 
     */
    create<T extends ExceptionCreateArgs>(args: SelectSubset<T, ExceptionCreateArgs<ExtArgs>>): Prisma__ExceptionClient<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Exceptions and returns the data saved in the database.
     * @param {ExceptionCreateManyAndReturnArgs} args - Arguments to create many Exceptions.
     * @example
     * // Create many Exceptions
     * const exception = await prisma.exception.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Exceptions and only return the `id`
     * const exceptionWithIdOnly = await prisma.exception.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ExceptionCreateManyAndReturnArgs>(args?: SelectSubset<T, ExceptionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Exception.
     * @param {ExceptionDeleteArgs} args - Arguments to delete one Exception.
     * @example
     * // Delete one Exception
     * const Exception = await prisma.exception.delete({
     *   where: {
     *     // ... filter to delete one Exception
     *   }
     * })
     * 
     */
    delete<T extends ExceptionDeleteArgs>(args: SelectSubset<T, ExceptionDeleteArgs<ExtArgs>>): Prisma__ExceptionClient<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Exception.
     * @param {ExceptionUpdateArgs} args - Arguments to update one Exception.
     * @example
     * // Update one Exception
     * const exception = await prisma.exception.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExceptionUpdateArgs>(args: SelectSubset<T, ExceptionUpdateArgs<ExtArgs>>): Prisma__ExceptionClient<$Result.GetResult<Prisma.$ExceptionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Exception.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExceptionGroupByArgs} 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 ExceptionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExceptionGroupByArgs['orderBy'] }
        : { orderBy?: ExceptionGroupByArgs['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, ExceptionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExceptionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Exception model
   */
  readonly fields: ExceptionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Exception.
   * 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__ExceptionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Slot<T extends SlotDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SlotDefaultArgs<ExtArgs>>): Prisma__SlotClient<$Result.GetResult<Prisma.$SlotPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Exception model
   */ 
  interface ExceptionFieldRefs {
    readonly id: FieldRef<"Exception", 'Int'>
    readonly date: FieldRef<"Exception", 'String'>
    readonly slotId: FieldRef<"Exception", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Exception findUnique
   */
  export type ExceptionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * Filter, which Exception to fetch.
     */
    where: ExceptionWhereUniqueInput
  }

  /**
   * Exception findUniqueOrThrow
   */
  export type ExceptionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * Filter, which Exception to fetch.
     */
    where: ExceptionWhereUniqueInput
  }

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

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

  /**
   * Exception findMany
   */
  export type ExceptionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * Filter, which Exceptions to fetch.
     */
    where?: ExceptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exceptions to fetch.
     */
    orderBy?: ExceptionOrderByWithRelationInput | ExceptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Exceptions.
     */
    cursor?: ExceptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exceptions 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` Exceptions.
     */
    skip?: number
    distinct?: ExceptionScalarFieldEnum | ExceptionScalarFieldEnum[]
  }

  /**
   * Exception create
   */
  export type ExceptionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * The data needed to create a Exception.
     */
    data: XOR<ExceptionCreateInput, ExceptionUncheckedCreateInput>
  }

  /**
   * Exception createMany
   */
  export type ExceptionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Exceptions.
     */
    data: ExceptionCreateManyInput | ExceptionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Exception createManyAndReturn
   */
  export type ExceptionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Exceptions.
     */
    data: ExceptionCreateManyInput | ExceptionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Exception update
   */
  export type ExceptionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * The data needed to update a Exception.
     */
    data: XOR<ExceptionUpdateInput, ExceptionUncheckedUpdateInput>
    /**
     * Choose, which Exception to update.
     */
    where: ExceptionWhereUniqueInput
  }

  /**
   * Exception updateMany
   */
  export type ExceptionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Exceptions.
     */
    data: XOR<ExceptionUpdateManyMutationInput, ExceptionUncheckedUpdateManyInput>
    /**
     * Filter which Exceptions to update
     */
    where?: ExceptionWhereInput
  }

  /**
   * Exception upsert
   */
  export type ExceptionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * The filter to search for the Exception to update in case it exists.
     */
    where: ExceptionWhereUniqueInput
    /**
     * In case the Exception found by the `where` argument doesn't exist, create a new Exception with this data.
     */
    create: XOR<ExceptionCreateInput, ExceptionUncheckedCreateInput>
    /**
     * In case the Exception was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExceptionUpdateInput, ExceptionUncheckedUpdateInput>
  }

  /**
   * Exception delete
   */
  export type ExceptionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
    /**
     * Filter which Exception to delete.
     */
    where: ExceptionWhereUniqueInput
  }

  /**
   * Exception deleteMany
   */
  export type ExceptionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Exceptions to delete
     */
    where?: ExceptionWhereInput
  }

  /**
   * Exception without action
   */
  export type ExceptionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exception
     */
    select?: ExceptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExceptionInclude<ExtArgs> | null
  }


  /**
   * Model Chat
   */

  export type AggregateChat = {
    _count: ChatCountAggregateOutputType | null
    _min: ChatMinAggregateOutputType | null
    _max: ChatMaxAggregateOutputType | null
  }

  export type ChatMinAggregateOutputType = {
    id: string | null
    createdAt: Date | null
    updatedAt: Date | null
    clientId: string | null
    expertId: string | null
  }

  export type ChatMaxAggregateOutputType = {
    id: string | null
    createdAt: Date | null
    updatedAt: Date | null
    clientId: string | null
    expertId: string | null
  }

  export type ChatCountAggregateOutputType = {
    id: number
    createdAt: number
    updatedAt: number
    clientId: number
    expertId: number
    _all: number
  }


  export type ChatMinAggregateInputType = {
    id?: true
    createdAt?: true
    updatedAt?: true
    clientId?: true
    expertId?: true
  }

  export type ChatMaxAggregateInputType = {
    id?: true
    createdAt?: true
    updatedAt?: true
    clientId?: true
    expertId?: true
  }

  export type ChatCountAggregateInputType = {
    id?: true
    createdAt?: true
    updatedAt?: true
    clientId?: true
    expertId?: true
    _all?: true
  }

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

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




  export type ChatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatWhereInput
    orderBy?: ChatOrderByWithAggregationInput | ChatOrderByWithAggregationInput[]
    by: ChatScalarFieldEnum[] | ChatScalarFieldEnum
    having?: ChatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChatCountAggregateInputType | true
    _min?: ChatMinAggregateInputType
    _max?: ChatMaxAggregateInputType
  }

  export type ChatGroupByOutputType = {
    id: string
    createdAt: Date
    updatedAt: Date
    clientId: string
    expertId: string
    _count: ChatCountAggregateOutputType | null
    _min: ChatMinAggregateOutputType | null
    _max: ChatMaxAggregateOutputType | null
  }

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


  export type ChatSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    clientId?: boolean
    expertId?: boolean
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    messages?: boolean | Chat$messagesArgs<ExtArgs>
    _count?: boolean | ChatCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["chat"]>

  export type ChatSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    clientId?: boolean
    expertId?: boolean
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["chat"]>

  export type ChatSelectScalar = {
    id?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    clientId?: boolean
    expertId?: boolean
  }

  export type ChatInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
    messages?: boolean | Chat$messagesArgs<ExtArgs>
    _count?: boolean | ChatCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ChatIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }

  export type $ChatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Chat"
    objects: {
      client: Prisma.$UserPayload<ExtArgs>
      expert: Prisma.$ExpertPayload<ExtArgs>
      messages: Prisma.$ChatMessagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      createdAt: Date
      updatedAt: Date
      clientId: string
      expertId: string
    }, ExtArgs["result"]["chat"]>
    composites: {}
  }

  type ChatGetPayload<S extends boolean | null | undefined | ChatDefaultArgs> = $Result.GetResult<Prisma.$ChatPayload, S>

  type ChatCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChatFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ChatCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Chat 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 {ChatFindFirstArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ChatFindFirstArgs>(args?: SelectSubset<T, ChatFindFirstArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Chat 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 {ChatFindFirstOrThrowArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ChatFindFirstOrThrowArgs>(args?: SelectSubset<T, ChatFindFirstOrThrowArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Chats 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 {ChatFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Chats
     * const chats = await prisma.chat.findMany()
     * 
     * // Get first 10 Chats
     * const chats = await prisma.chat.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const chatWithIdOnly = await prisma.chat.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ChatFindManyArgs>(args?: SelectSubset<T, ChatFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Chat.
     * @param {ChatCreateArgs} args - Arguments to create a Chat.
     * @example
     * // Create one Chat
     * const Chat = await prisma.chat.create({
     *   data: {
     *     // ... data to create a Chat
     *   }
     * })
     * 
     */
    create<T extends ChatCreateArgs>(args: SelectSubset<T, ChatCreateArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Chats and returns the data saved in the database.
     * @param {ChatCreateManyAndReturnArgs} args - Arguments to create many Chats.
     * @example
     * // Create many Chats
     * const chat = await prisma.chat.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Chats and only return the `id`
     * const chatWithIdOnly = await prisma.chat.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ChatCreateManyAndReturnArgs>(args?: SelectSubset<T, ChatCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Chat.
     * @param {ChatDeleteArgs} args - Arguments to delete one Chat.
     * @example
     * // Delete one Chat
     * const Chat = await prisma.chat.delete({
     *   where: {
     *     // ... filter to delete one Chat
     *   }
     * })
     * 
     */
    delete<T extends ChatDeleteArgs>(args: SelectSubset<T, ChatDeleteArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Chat.
     * @param {ChatUpdateArgs} args - Arguments to update one Chat.
     * @example
     * // Update one Chat
     * const chat = await prisma.chat.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ChatUpdateArgs>(args: SelectSubset<T, ChatUpdateArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Chat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatGroupByArgs} 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 ChatGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ChatGroupByArgs['orderBy'] }
        : { orderBy?: ChatGroupByArgs['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, ChatGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetChatGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Chat model
   */
  readonly fields: ChatFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Chat.
   * 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__ChatClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    client<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    messages<T extends Chat$messagesArgs<ExtArgs> = {}>(args?: Subset<T, Chat$messagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findMany"> | 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 Chat model
   */ 
  interface ChatFieldRefs {
    readonly id: FieldRef<"Chat", 'String'>
    readonly createdAt: FieldRef<"Chat", 'DateTime'>
    readonly updatedAt: FieldRef<"Chat", 'DateTime'>
    readonly clientId: FieldRef<"Chat", 'String'>
    readonly expertId: FieldRef<"Chat", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Chat findUnique
   */
  export type ChatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat findUniqueOrThrow
   */
  export type ChatFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where: ChatWhereUniqueInput
  }

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

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

  /**
   * Chat findMany
   */
  export type ChatFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * Filter, which Chats to fetch.
     */
    where?: ChatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Chats to fetch.
     */
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Chats.
     */
    cursor?: ChatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Chats 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` Chats.
     */
    skip?: number
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * Chat create
   */
  export type ChatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * The data needed to create a Chat.
     */
    data: XOR<ChatCreateInput, ChatUncheckedCreateInput>
  }

  /**
   * Chat createMany
   */
  export type ChatCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Chats.
     */
    data: ChatCreateManyInput | ChatCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Chat createManyAndReturn
   */
  export type ChatCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Chats.
     */
    data: ChatCreateManyInput | ChatCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Chat update
   */
  export type ChatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * The data needed to update a Chat.
     */
    data: XOR<ChatUpdateInput, ChatUncheckedUpdateInput>
    /**
     * Choose, which Chat to update.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat updateMany
   */
  export type ChatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Chats.
     */
    data: XOR<ChatUpdateManyMutationInput, ChatUncheckedUpdateManyInput>
    /**
     * Filter which Chats to update
     */
    where?: ChatWhereInput
  }

  /**
   * Chat upsert
   */
  export type ChatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * The filter to search for the Chat to update in case it exists.
     */
    where: ChatWhereUniqueInput
    /**
     * In case the Chat found by the `where` argument doesn't exist, create a new Chat with this data.
     */
    create: XOR<ChatCreateInput, ChatUncheckedCreateInput>
    /**
     * In case the Chat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChatUpdateInput, ChatUncheckedUpdateInput>
  }

  /**
   * Chat delete
   */
  export type ChatDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
    /**
     * Filter which Chat to delete.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat deleteMany
   */
  export type ChatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Chats to delete
     */
    where?: ChatWhereInput
  }

  /**
   * Chat.messages
   */
  export type Chat$messagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    where?: ChatMessageWhereInput
    orderBy?: ChatMessageOrderByWithRelationInput | ChatMessageOrderByWithRelationInput[]
    cursor?: ChatMessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChatMessageScalarFieldEnum | ChatMessageScalarFieldEnum[]
  }

  /**
   * Chat without action
   */
  export type ChatDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatInclude<ExtArgs> | null
  }


  /**
   * Model ChatMessage
   */

  export type AggregateChatMessage = {
    _count: ChatMessageCountAggregateOutputType | null
    _avg: ChatMessageAvgAggregateOutputType | null
    _sum: ChatMessageSumAggregateOutputType | null
    _min: ChatMessageMinAggregateOutputType | null
    _max: ChatMessageMaxAggregateOutputType | null
  }

  export type ChatMessageAvgAggregateOutputType = {
    id: number | null
  }

  export type ChatMessageSumAggregateOutputType = {
    id: number | null
  }

  export type ChatMessageMinAggregateOutputType = {
    id: number | null
    content: string | null
    userId: string | null
    fileName: string | null
    type: string | null
    fileType: string | null
    fileUrl: string | null
    createdAt: Date | null
    chatId: string | null
    senderId: string | null
    expertId: string | null
  }

  export type ChatMessageMaxAggregateOutputType = {
    id: number | null
    content: string | null
    userId: string | null
    fileName: string | null
    type: string | null
    fileType: string | null
    fileUrl: string | null
    createdAt: Date | null
    chatId: string | null
    senderId: string | null
    expertId: string | null
  }

  export type ChatMessageCountAggregateOutputType = {
    id: number
    content: number
    userId: number
    fileName: number
    type: number
    fileType: number
    fileUrl: number
    createdAt: number
    chatId: number
    senderId: number
    expertId: number
    _all: number
  }


  export type ChatMessageAvgAggregateInputType = {
    id?: true
  }

  export type ChatMessageSumAggregateInputType = {
    id?: true
  }

  export type ChatMessageMinAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    fileName?: true
    type?: true
    fileType?: true
    fileUrl?: true
    createdAt?: true
    chatId?: true
    senderId?: true
    expertId?: true
  }

  export type ChatMessageMaxAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    fileName?: true
    type?: true
    fileType?: true
    fileUrl?: true
    createdAt?: true
    chatId?: true
    senderId?: true
    expertId?: true
  }

  export type ChatMessageCountAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    fileName?: true
    type?: true
    fileType?: true
    fileUrl?: true
    createdAt?: true
    chatId?: true
    senderId?: true
    expertId?: true
    _all?: true
  }

  export type ChatMessageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChatMessage to aggregate.
     */
    where?: ChatMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChatMessages to fetch.
     */
    orderBy?: ChatMessageOrderByWithRelationInput | ChatMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChatMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChatMessages 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` ChatMessages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChatMessages
    **/
    _count?: true | ChatMessageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChatMessageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChatMessageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChatMessageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChatMessageMaxAggregateInputType
  }

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




  export type ChatMessageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatMessageWhereInput
    orderBy?: ChatMessageOrderByWithAggregationInput | ChatMessageOrderByWithAggregationInput[]
    by: ChatMessageScalarFieldEnum[] | ChatMessageScalarFieldEnum
    having?: ChatMessageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChatMessageCountAggregateInputType | true
    _avg?: ChatMessageAvgAggregateInputType
    _sum?: ChatMessageSumAggregateInputType
    _min?: ChatMessageMinAggregateInputType
    _max?: ChatMessageMaxAggregateInputType
  }

  export type ChatMessageGroupByOutputType = {
    id: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl: string
    createdAt: Date
    chatId: string
    senderId: string
    expertId: string | null
    _count: ChatMessageCountAggregateOutputType | null
    _avg: ChatMessageAvgAggregateOutputType | null
    _sum: ChatMessageSumAggregateOutputType | null
    _min: ChatMessageMinAggregateOutputType | null
    _max: ChatMessageMaxAggregateOutputType | null
  }

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


  export type ChatMessageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    userId?: boolean
    fileName?: boolean
    type?: boolean
    fileType?: boolean
    fileUrl?: boolean
    createdAt?: boolean
    chatId?: boolean
    senderId?: boolean
    expertId?: boolean
    chat?: boolean | ChatDefaultArgs<ExtArgs>
    Expert?: boolean | ChatMessage$ExpertArgs<ExtArgs>
    sender?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["chatMessage"]>

  export type ChatMessageSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    userId?: boolean
    fileName?: boolean
    type?: boolean
    fileType?: boolean
    fileUrl?: boolean
    createdAt?: boolean
    chatId?: boolean
    senderId?: boolean
    expertId?: boolean
    chat?: boolean | ChatDefaultArgs<ExtArgs>
    Expert?: boolean | ChatMessage$ExpertArgs<ExtArgs>
    sender?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["chatMessage"]>

  export type ChatMessageSelectScalar = {
    id?: boolean
    content?: boolean
    userId?: boolean
    fileName?: boolean
    type?: boolean
    fileType?: boolean
    fileUrl?: boolean
    createdAt?: boolean
    chatId?: boolean
    senderId?: boolean
    expertId?: boolean
  }

  export type ChatMessageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    chat?: boolean | ChatDefaultArgs<ExtArgs>
    Expert?: boolean | ChatMessage$ExpertArgs<ExtArgs>
    sender?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ChatMessageIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    chat?: boolean | ChatDefaultArgs<ExtArgs>
    Expert?: boolean | ChatMessage$ExpertArgs<ExtArgs>
    sender?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ChatMessagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChatMessage"
    objects: {
      chat: Prisma.$ChatPayload<ExtArgs>
      Expert: Prisma.$ExpertPayload<ExtArgs> | null
      sender: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      content: string
      userId: string
      fileName: string
      type: string
      fileType: string
      fileUrl: string
      createdAt: Date
      chatId: string
      senderId: string
      expertId: string | null
    }, ExtArgs["result"]["chatMessage"]>
    composites: {}
  }

  type ChatMessageGetPayload<S extends boolean | null | undefined | ChatMessageDefaultArgs> = $Result.GetResult<Prisma.$ChatMessagePayload, S>

  type ChatMessageCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChatMessageFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ChatMessageCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ChatMessage 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 {ChatMessageFindFirstArgs} args - Arguments to find a ChatMessage
     * @example
     * // Get one ChatMessage
     * const chatMessage = await prisma.chatMessage.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ChatMessageFindFirstArgs>(args?: SelectSubset<T, ChatMessageFindFirstArgs<ExtArgs>>): Prisma__ChatMessageClient<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ChatMessage 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 {ChatMessageFindFirstOrThrowArgs} args - Arguments to find a ChatMessage
     * @example
     * // Get one ChatMessage
     * const chatMessage = await prisma.chatMessage.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ChatMessageFindFirstOrThrowArgs>(args?: SelectSubset<T, ChatMessageFindFirstOrThrowArgs<ExtArgs>>): Prisma__ChatMessageClient<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ChatMessages 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 {ChatMessageFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ChatMessages
     * const chatMessages = await prisma.chatMessage.findMany()
     * 
     * // Get first 10 ChatMessages
     * const chatMessages = await prisma.chatMessage.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const chatMessageWithIdOnly = await prisma.chatMessage.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ChatMessageFindManyArgs>(args?: SelectSubset<T, ChatMessageFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ChatMessage.
     * @param {ChatMessageCreateArgs} args - Arguments to create a ChatMessage.
     * @example
     * // Create one ChatMessage
     * const ChatMessage = await prisma.chatMessage.create({
     *   data: {
     *     // ... data to create a ChatMessage
     *   }
     * })
     * 
     */
    create<T extends ChatMessageCreateArgs>(args: SelectSubset<T, ChatMessageCreateArgs<ExtArgs>>): Prisma__ChatMessageClient<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many ChatMessages and returns the data saved in the database.
     * @param {ChatMessageCreateManyAndReturnArgs} args - Arguments to create many ChatMessages.
     * @example
     * // Create many ChatMessages
     * const chatMessage = await prisma.chatMessage.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ChatMessages and only return the `id`
     * const chatMessageWithIdOnly = await prisma.chatMessage.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ChatMessageCreateManyAndReturnArgs>(args?: SelectSubset<T, ChatMessageCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a ChatMessage.
     * @param {ChatMessageDeleteArgs} args - Arguments to delete one ChatMessage.
     * @example
     * // Delete one ChatMessage
     * const ChatMessage = await prisma.chatMessage.delete({
     *   where: {
     *     // ... filter to delete one ChatMessage
     *   }
     * })
     * 
     */
    delete<T extends ChatMessageDeleteArgs>(args: SelectSubset<T, ChatMessageDeleteArgs<ExtArgs>>): Prisma__ChatMessageClient<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ChatMessage.
     * @param {ChatMessageUpdateArgs} args - Arguments to update one ChatMessage.
     * @example
     * // Update one ChatMessage
     * const chatMessage = await prisma.chatMessage.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ChatMessageUpdateArgs>(args: SelectSubset<T, ChatMessageUpdateArgs<ExtArgs>>): Prisma__ChatMessageClient<$Result.GetResult<Prisma.$ChatMessagePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by ChatMessage.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatMessageGroupByArgs} 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 ChatMessageGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ChatMessageGroupByArgs['orderBy'] }
        : { orderBy?: ChatMessageGroupByArgs['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, ChatMessageGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetChatMessageGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ChatMessage model
   */
  readonly fields: ChatMessageFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ChatMessage.
   * 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__ChatMessageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    chat<T extends ChatDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ChatDefaultArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    Expert<T extends ChatMessage$ExpertArgs<ExtArgs> = {}>(args?: Subset<T, ChatMessage$ExpertArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    sender<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 ChatMessage model
   */ 
  interface ChatMessageFieldRefs {
    readonly id: FieldRef<"ChatMessage", 'Int'>
    readonly content: FieldRef<"ChatMessage", 'String'>
    readonly userId: FieldRef<"ChatMessage", 'String'>
    readonly fileName: FieldRef<"ChatMessage", 'String'>
    readonly type: FieldRef<"ChatMessage", 'String'>
    readonly fileType: FieldRef<"ChatMessage", 'String'>
    readonly fileUrl: FieldRef<"ChatMessage", 'String'>
    readonly createdAt: FieldRef<"ChatMessage", 'DateTime'>
    readonly chatId: FieldRef<"ChatMessage", 'String'>
    readonly senderId: FieldRef<"ChatMessage", 'String'>
    readonly expertId: FieldRef<"ChatMessage", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ChatMessage findUnique
   */
  export type ChatMessageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * Filter, which ChatMessage to fetch.
     */
    where: ChatMessageWhereUniqueInput
  }

  /**
   * ChatMessage findUniqueOrThrow
   */
  export type ChatMessageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * Filter, which ChatMessage to fetch.
     */
    where: ChatMessageWhereUniqueInput
  }

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

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

  /**
   * ChatMessage findMany
   */
  export type ChatMessageFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * Filter, which ChatMessages to fetch.
     */
    where?: ChatMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChatMessages to fetch.
     */
    orderBy?: ChatMessageOrderByWithRelationInput | ChatMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ChatMessages.
     */
    cursor?: ChatMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChatMessages 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` ChatMessages.
     */
    skip?: number
    distinct?: ChatMessageScalarFieldEnum | ChatMessageScalarFieldEnum[]
  }

  /**
   * ChatMessage create
   */
  export type ChatMessageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * The data needed to create a ChatMessage.
     */
    data: XOR<ChatMessageCreateInput, ChatMessageUncheckedCreateInput>
  }

  /**
   * ChatMessage createMany
   */
  export type ChatMessageCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ChatMessages.
     */
    data: ChatMessageCreateManyInput | ChatMessageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ChatMessage createManyAndReturn
   */
  export type ChatMessageCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ChatMessages.
     */
    data: ChatMessageCreateManyInput | ChatMessageCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ChatMessage update
   */
  export type ChatMessageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * The data needed to update a ChatMessage.
     */
    data: XOR<ChatMessageUpdateInput, ChatMessageUncheckedUpdateInput>
    /**
     * Choose, which ChatMessage to update.
     */
    where: ChatMessageWhereUniqueInput
  }

  /**
   * ChatMessage updateMany
   */
  export type ChatMessageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChatMessages.
     */
    data: XOR<ChatMessageUpdateManyMutationInput, ChatMessageUncheckedUpdateManyInput>
    /**
     * Filter which ChatMessages to update
     */
    where?: ChatMessageWhereInput
  }

  /**
   * ChatMessage upsert
   */
  export type ChatMessageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * The filter to search for the ChatMessage to update in case it exists.
     */
    where: ChatMessageWhereUniqueInput
    /**
     * In case the ChatMessage found by the `where` argument doesn't exist, create a new ChatMessage with this data.
     */
    create: XOR<ChatMessageCreateInput, ChatMessageUncheckedCreateInput>
    /**
     * In case the ChatMessage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChatMessageUpdateInput, ChatMessageUncheckedUpdateInput>
  }

  /**
   * ChatMessage delete
   */
  export type ChatMessageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
    /**
     * Filter which ChatMessage to delete.
     */
    where: ChatMessageWhereUniqueInput
  }

  /**
   * ChatMessage deleteMany
   */
  export type ChatMessageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChatMessages to delete
     */
    where?: ChatMessageWhereInput
  }

  /**
   * ChatMessage.Expert
   */
  export type ChatMessage$ExpertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Expert
     */
    select?: ExpertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertInclude<ExtArgs> | null
    where?: ExpertWhereInput
  }

  /**
   * ChatMessage without action
   */
  export type ChatMessageDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChatMessage
     */
    select?: ChatMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ChatMessageInclude<ExtArgs> | null
  }


  /**
   * Model ClientReview
   */

  export type AggregateClientReview = {
    _count: ClientReviewCountAggregateOutputType | null
    _avg: ClientReviewAvgAggregateOutputType | null
    _sum: ClientReviewSumAggregateOutputType | null
    _min: ClientReviewMinAggregateOutputType | null
    _max: ClientReviewMaxAggregateOutputType | null
  }

  export type ClientReviewAvgAggregateOutputType = {
    id: number | null
  }

  export type ClientReviewSumAggregateOutputType = {
    id: number | null
  }

  export type ClientReviewMinAggregateOutputType = {
    id: number | null
    reviewText: string | null
    createdAt: Date | null
    videoRoomId: string | null
    appointmentKey: string | null
    isDisplayed: boolean | null
    clientId: string | null
    expertId: string | null
  }

  export type ClientReviewMaxAggregateOutputType = {
    id: number | null
    reviewText: string | null
    createdAt: Date | null
    videoRoomId: string | null
    appointmentKey: string | null
    isDisplayed: boolean | null
    clientId: string | null
    expertId: string | null
  }

  export type ClientReviewCountAggregateOutputType = {
    id: number
    reviewText: number
    createdAt: number
    videoRoomId: number
    appointmentKey: number
    isDisplayed: number
    clientId: number
    expertId: number
    _all: number
  }


  export type ClientReviewAvgAggregateInputType = {
    id?: true
  }

  export type ClientReviewSumAggregateInputType = {
    id?: true
  }

  export type ClientReviewMinAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
    expertId?: true
  }

  export type ClientReviewMaxAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
    expertId?: true
  }

  export type ClientReviewCountAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
    expertId?: true
    _all?: true
  }

  export type ClientReviewAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ClientReview to aggregate.
     */
    where?: ClientReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ClientReviews to fetch.
     */
    orderBy?: ClientReviewOrderByWithRelationInput | ClientReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ClientReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ClientReviews 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` ClientReviews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ClientReviews
    **/
    _count?: true | ClientReviewCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ClientReviewAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ClientReviewSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ClientReviewMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ClientReviewMaxAggregateInputType
  }

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




  export type ClientReviewGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClientReviewWhereInput
    orderBy?: ClientReviewOrderByWithAggregationInput | ClientReviewOrderByWithAggregationInput[]
    by: ClientReviewScalarFieldEnum[] | ClientReviewScalarFieldEnum
    having?: ClientReviewScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ClientReviewCountAggregateInputType | true
    _avg?: ClientReviewAvgAggregateInputType
    _sum?: ClientReviewSumAggregateInputType
    _min?: ClientReviewMinAggregateInputType
    _max?: ClientReviewMaxAggregateInputType
  }

  export type ClientReviewGroupByOutputType = {
    id: number
    reviewText: string
    createdAt: Date
    videoRoomId: string
    appointmentKey: string
    isDisplayed: boolean
    clientId: string
    expertId: string
    _count: ClientReviewCountAggregateOutputType | null
    _avg: ClientReviewAvgAggregateOutputType | null
    _sum: ClientReviewSumAggregateOutputType | null
    _min: ClientReviewMinAggregateOutputType | null
    _max: ClientReviewMaxAggregateOutputType | null
  }

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


  export type ClientReviewSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
    expertId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["clientReview"]>

  export type ClientReviewSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
    expertId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["clientReview"]>

  export type ClientReviewSelectScalar = {
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
    expertId?: boolean
  }

  export type ClientReviewInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }
  export type ClientReviewIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }

  export type $ClientReviewPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ClientReview"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      client: Prisma.$UserPayload<ExtArgs>
      expert: Prisma.$ExpertPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      reviewText: string
      createdAt: Date
      videoRoomId: string
      appointmentKey: string
      isDisplayed: boolean
      clientId: string
      expertId: string
    }, ExtArgs["result"]["clientReview"]>
    composites: {}
  }

  type ClientReviewGetPayload<S extends boolean | null | undefined | ClientReviewDefaultArgs> = $Result.GetResult<Prisma.$ClientReviewPayload, S>

  type ClientReviewCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ClientReviewFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ClientReviewCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ClientReview 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 {ClientReviewFindFirstArgs} args - Arguments to find a ClientReview
     * @example
     * // Get one ClientReview
     * const clientReview = await prisma.clientReview.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ClientReviewFindFirstArgs>(args?: SelectSubset<T, ClientReviewFindFirstArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ClientReview 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 {ClientReviewFindFirstOrThrowArgs} args - Arguments to find a ClientReview
     * @example
     * // Get one ClientReview
     * const clientReview = await prisma.clientReview.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ClientReviewFindFirstOrThrowArgs>(args?: SelectSubset<T, ClientReviewFindFirstOrThrowArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ClientReviews 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 {ClientReviewFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ClientReviews
     * const clientReviews = await prisma.clientReview.findMany()
     * 
     * // Get first 10 ClientReviews
     * const clientReviews = await prisma.clientReview.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const clientReviewWithIdOnly = await prisma.clientReview.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ClientReviewFindManyArgs>(args?: SelectSubset<T, ClientReviewFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ClientReview.
     * @param {ClientReviewCreateArgs} args - Arguments to create a ClientReview.
     * @example
     * // Create one ClientReview
     * const ClientReview = await prisma.clientReview.create({
     *   data: {
     *     // ... data to create a ClientReview
     *   }
     * })
     * 
     */
    create<T extends ClientReviewCreateArgs>(args: SelectSubset<T, ClientReviewCreateArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many ClientReviews and returns the data saved in the database.
     * @param {ClientReviewCreateManyAndReturnArgs} args - Arguments to create many ClientReviews.
     * @example
     * // Create many ClientReviews
     * const clientReview = await prisma.clientReview.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ClientReviews and only return the `id`
     * const clientReviewWithIdOnly = await prisma.clientReview.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ClientReviewCreateManyAndReturnArgs>(args?: SelectSubset<T, ClientReviewCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a ClientReview.
     * @param {ClientReviewDeleteArgs} args - Arguments to delete one ClientReview.
     * @example
     * // Delete one ClientReview
     * const ClientReview = await prisma.clientReview.delete({
     *   where: {
     *     // ... filter to delete one ClientReview
     *   }
     * })
     * 
     */
    delete<T extends ClientReviewDeleteArgs>(args: SelectSubset<T, ClientReviewDeleteArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ClientReview.
     * @param {ClientReviewUpdateArgs} args - Arguments to update one ClientReview.
     * @example
     * // Update one ClientReview
     * const clientReview = await prisma.clientReview.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ClientReviewUpdateArgs>(args: SelectSubset<T, ClientReviewUpdateArgs<ExtArgs>>): Prisma__ClientReviewClient<$Result.GetResult<Prisma.$ClientReviewPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by ClientReview.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ClientReviewGroupByArgs} 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 ClientReviewGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ClientReviewGroupByArgs['orderBy'] }
        : { orderBy?: ClientReviewGroupByArgs['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, ClientReviewGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetClientReviewGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ClientReview model
   */
  readonly fields: ClientReviewFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ClientReview.
   * 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__ClientReviewClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    client<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 ClientReview model
   */ 
  interface ClientReviewFieldRefs {
    readonly id: FieldRef<"ClientReview", 'Int'>
    readonly reviewText: FieldRef<"ClientReview", 'String'>
    readonly createdAt: FieldRef<"ClientReview", 'DateTime'>
    readonly videoRoomId: FieldRef<"ClientReview", 'String'>
    readonly appointmentKey: FieldRef<"ClientReview", 'String'>
    readonly isDisplayed: FieldRef<"ClientReview", 'Boolean'>
    readonly clientId: FieldRef<"ClientReview", 'String'>
    readonly expertId: FieldRef<"ClientReview", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ClientReview findUnique
   */
  export type ClientReviewFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * Filter, which ClientReview to fetch.
     */
    where: ClientReviewWhereUniqueInput
  }

  /**
   * ClientReview findUniqueOrThrow
   */
  export type ClientReviewFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * Filter, which ClientReview to fetch.
     */
    where: ClientReviewWhereUniqueInput
  }

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

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

  /**
   * ClientReview findMany
   */
  export type ClientReviewFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * Filter, which ClientReviews to fetch.
     */
    where?: ClientReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ClientReviews to fetch.
     */
    orderBy?: ClientReviewOrderByWithRelationInput | ClientReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ClientReviews.
     */
    cursor?: ClientReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ClientReviews 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` ClientReviews.
     */
    skip?: number
    distinct?: ClientReviewScalarFieldEnum | ClientReviewScalarFieldEnum[]
  }

  /**
   * ClientReview create
   */
  export type ClientReviewCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * The data needed to create a ClientReview.
     */
    data: XOR<ClientReviewCreateInput, ClientReviewUncheckedCreateInput>
  }

  /**
   * ClientReview createMany
   */
  export type ClientReviewCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ClientReviews.
     */
    data: ClientReviewCreateManyInput | ClientReviewCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ClientReview createManyAndReturn
   */
  export type ClientReviewCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ClientReviews.
     */
    data: ClientReviewCreateManyInput | ClientReviewCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ClientReview update
   */
  export type ClientReviewUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * The data needed to update a ClientReview.
     */
    data: XOR<ClientReviewUpdateInput, ClientReviewUncheckedUpdateInput>
    /**
     * Choose, which ClientReview to update.
     */
    where: ClientReviewWhereUniqueInput
  }

  /**
   * ClientReview updateMany
   */
  export type ClientReviewUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ClientReviews.
     */
    data: XOR<ClientReviewUpdateManyMutationInput, ClientReviewUncheckedUpdateManyInput>
    /**
     * Filter which ClientReviews to update
     */
    where?: ClientReviewWhereInput
  }

  /**
   * ClientReview upsert
   */
  export type ClientReviewUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * The filter to search for the ClientReview to update in case it exists.
     */
    where: ClientReviewWhereUniqueInput
    /**
     * In case the ClientReview found by the `where` argument doesn't exist, create a new ClientReview with this data.
     */
    create: XOR<ClientReviewCreateInput, ClientReviewUncheckedCreateInput>
    /**
     * In case the ClientReview was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ClientReviewUpdateInput, ClientReviewUncheckedUpdateInput>
  }

  /**
   * ClientReview delete
   */
  export type ClientReviewDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
    /**
     * Filter which ClientReview to delete.
     */
    where: ClientReviewWhereUniqueInput
  }

  /**
   * ClientReview deleteMany
   */
  export type ClientReviewDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ClientReviews to delete
     */
    where?: ClientReviewWhereInput
  }

  /**
   * ClientReview without action
   */
  export type ClientReviewDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClientReview
     */
    select?: ClientReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClientReviewInclude<ExtArgs> | null
  }


  /**
   * Model ExpertReview
   */

  export type AggregateExpertReview = {
    _count: ExpertReviewCountAggregateOutputType | null
    _avg: ExpertReviewAvgAggregateOutputType | null
    _sum: ExpertReviewSumAggregateOutputType | null
    _min: ExpertReviewMinAggregateOutputType | null
    _max: ExpertReviewMaxAggregateOutputType | null
  }

  export type ExpertReviewAvgAggregateOutputType = {
    id: number | null
  }

  export type ExpertReviewSumAggregateOutputType = {
    id: number | null
  }

  export type ExpertReviewMinAggregateOutputType = {
    id: number | null
    reviewText: string | null
    createdAt: Date | null
    videoRoomId: string | null
    expertId: string | null
    appointmentKey: string | null
    isDisplayed: boolean | null
    clientId: string | null
  }

  export type ExpertReviewMaxAggregateOutputType = {
    id: number | null
    reviewText: string | null
    createdAt: Date | null
    videoRoomId: string | null
    expertId: string | null
    appointmentKey: string | null
    isDisplayed: boolean | null
    clientId: string | null
  }

  export type ExpertReviewCountAggregateOutputType = {
    id: number
    reviewText: number
    createdAt: number
    videoRoomId: number
    expertId: number
    appointmentKey: number
    isDisplayed: number
    clientId: number
    _all: number
  }


  export type ExpertReviewAvgAggregateInputType = {
    id?: true
  }

  export type ExpertReviewSumAggregateInputType = {
    id?: true
  }

  export type ExpertReviewMinAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    expertId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
  }

  export type ExpertReviewMaxAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    expertId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
  }

  export type ExpertReviewCountAggregateInputType = {
    id?: true
    reviewText?: true
    createdAt?: true
    videoRoomId?: true
    expertId?: true
    appointmentKey?: true
    isDisplayed?: true
    clientId?: true
    _all?: true
  }

  export type ExpertReviewAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExpertReview to aggregate.
     */
    where?: ExpertReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExpertReviews to fetch.
     */
    orderBy?: ExpertReviewOrderByWithRelationInput | ExpertReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExpertReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExpertReviews 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` ExpertReviews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ExpertReviews
    **/
    _count?: true | ExpertReviewCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExpertReviewAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExpertReviewSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExpertReviewMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExpertReviewMaxAggregateInputType
  }

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




  export type ExpertReviewGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExpertReviewWhereInput
    orderBy?: ExpertReviewOrderByWithAggregationInput | ExpertReviewOrderByWithAggregationInput[]
    by: ExpertReviewScalarFieldEnum[] | ExpertReviewScalarFieldEnum
    having?: ExpertReviewScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertReviewCountAggregateInputType | true
    _avg?: ExpertReviewAvgAggregateInputType
    _sum?: ExpertReviewSumAggregateInputType
    _min?: ExpertReviewMinAggregateInputType
    _max?: ExpertReviewMaxAggregateInputType
  }

  export type ExpertReviewGroupByOutputType = {
    id: number
    reviewText: string | null
    createdAt: Date
    videoRoomId: string
    expertId: string
    appointmentKey: string
    isDisplayed: boolean
    clientId: string
    _count: ExpertReviewCountAggregateOutputType | null
    _avg: ExpertReviewAvgAggregateOutputType | null
    _sum: ExpertReviewSumAggregateOutputType | null
    _min: ExpertReviewMinAggregateOutputType | null
    _max: ExpertReviewMaxAggregateOutputType | null
  }

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


  export type ExpertReviewSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    expertId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertReview"]>

  export type ExpertReviewSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    expertId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertReview"]>

  export type ExpertReviewSelectScalar = {
    id?: boolean
    reviewText?: boolean
    createdAt?: boolean
    videoRoomId?: boolean
    expertId?: boolean
    appointmentKey?: boolean
    isDisplayed?: boolean
    clientId?: boolean
  }

  export type ExpertReviewInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }
  export type ExpertReviewIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    client?: boolean | UserDefaultArgs<ExtArgs>
    expert?: boolean | ExpertDefaultArgs<ExtArgs>
  }

  export type $ExpertReviewPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ExpertReview"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      client: Prisma.$UserPayload<ExtArgs>
      expert: Prisma.$ExpertPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      reviewText: string | null
      createdAt: Date
      videoRoomId: string
      expertId: string
      appointmentKey: string
      isDisplayed: boolean
      clientId: string
    }, ExtArgs["result"]["expertReview"]>
    composites: {}
  }

  type ExpertReviewGetPayload<S extends boolean | null | undefined | ExpertReviewDefaultArgs> = $Result.GetResult<Prisma.$ExpertReviewPayload, S>

  type ExpertReviewCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExpertReviewFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExpertReviewCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ExpertReview 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 {ExpertReviewFindFirstArgs} args - Arguments to find a ExpertReview
     * @example
     * // Get one ExpertReview
     * const expertReview = await prisma.expertReview.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExpertReviewFindFirstArgs>(args?: SelectSubset<T, ExpertReviewFindFirstArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ExpertReview 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 {ExpertReviewFindFirstOrThrowArgs} args - Arguments to find a ExpertReview
     * @example
     * // Get one ExpertReview
     * const expertReview = await prisma.expertReview.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExpertReviewFindFirstOrThrowArgs>(args?: SelectSubset<T, ExpertReviewFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ExpertReviews 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 {ExpertReviewFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ExpertReviews
     * const expertReviews = await prisma.expertReview.findMany()
     * 
     * // Get first 10 ExpertReviews
     * const expertReviews = await prisma.expertReview.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const expertReviewWithIdOnly = await prisma.expertReview.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExpertReviewFindManyArgs>(args?: SelectSubset<T, ExpertReviewFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ExpertReview.
     * @param {ExpertReviewCreateArgs} args - Arguments to create a ExpertReview.
     * @example
     * // Create one ExpertReview
     * const ExpertReview = await prisma.expertReview.create({
     *   data: {
     *     // ... data to create a ExpertReview
     *   }
     * })
     * 
     */
    create<T extends ExpertReviewCreateArgs>(args: SelectSubset<T, ExpertReviewCreateArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many ExpertReviews and returns the data saved in the database.
     * @param {ExpertReviewCreateManyAndReturnArgs} args - Arguments to create many ExpertReviews.
     * @example
     * // Create many ExpertReviews
     * const expertReview = await prisma.expertReview.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ExpertReviews and only return the `id`
     * const expertReviewWithIdOnly = await prisma.expertReview.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ExpertReviewCreateManyAndReturnArgs>(args?: SelectSubset<T, ExpertReviewCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a ExpertReview.
     * @param {ExpertReviewDeleteArgs} args - Arguments to delete one ExpertReview.
     * @example
     * // Delete one ExpertReview
     * const ExpertReview = await prisma.expertReview.delete({
     *   where: {
     *     // ... filter to delete one ExpertReview
     *   }
     * })
     * 
     */
    delete<T extends ExpertReviewDeleteArgs>(args: SelectSubset<T, ExpertReviewDeleteArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ExpertReview.
     * @param {ExpertReviewUpdateArgs} args - Arguments to update one ExpertReview.
     * @example
     * // Update one ExpertReview
     * const expertReview = await prisma.expertReview.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExpertReviewUpdateArgs>(args: SelectSubset<T, ExpertReviewUpdateArgs<ExtArgs>>): Prisma__ExpertReviewClient<$Result.GetResult<Prisma.$ExpertReviewPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by ExpertReview.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExpertReviewGroupByArgs} 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 ExpertReviewGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExpertReviewGroupByArgs['orderBy'] }
        : { orderBy?: ExpertReviewGroupByArgs['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, ExpertReviewGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExpertReviewGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ExpertReview model
   */
  readonly fields: ExpertReviewFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ExpertReview.
   * 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__ExpertReviewClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    client<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    expert<T extends ExpertDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ExpertDefaultArgs<ExtArgs>>): Prisma__ExpertClient<$Result.GetResult<Prisma.$ExpertPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 ExpertReview model
   */ 
  interface ExpertReviewFieldRefs {
    readonly id: FieldRef<"ExpertReview", 'Int'>
    readonly reviewText: FieldRef<"ExpertReview", 'String'>
    readonly createdAt: FieldRef<"ExpertReview", 'DateTime'>
    readonly videoRoomId: FieldRef<"ExpertReview", 'String'>
    readonly expertId: FieldRef<"ExpertReview", 'String'>
    readonly appointmentKey: FieldRef<"ExpertReview", 'String'>
    readonly isDisplayed: FieldRef<"ExpertReview", 'Boolean'>
    readonly clientId: FieldRef<"ExpertReview", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ExpertReview findUnique
   */
  export type ExpertReviewFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * Filter, which ExpertReview to fetch.
     */
    where: ExpertReviewWhereUniqueInput
  }

  /**
   * ExpertReview findUniqueOrThrow
   */
  export type ExpertReviewFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * Filter, which ExpertReview to fetch.
     */
    where: ExpertReviewWhereUniqueInput
  }

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

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

  /**
   * ExpertReview findMany
   */
  export type ExpertReviewFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * Filter, which ExpertReviews to fetch.
     */
    where?: ExpertReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExpertReviews to fetch.
     */
    orderBy?: ExpertReviewOrderByWithRelationInput | ExpertReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ExpertReviews.
     */
    cursor?: ExpertReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExpertReviews 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` ExpertReviews.
     */
    skip?: number
    distinct?: ExpertReviewScalarFieldEnum | ExpertReviewScalarFieldEnum[]
  }

  /**
   * ExpertReview create
   */
  export type ExpertReviewCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * The data needed to create a ExpertReview.
     */
    data: XOR<ExpertReviewCreateInput, ExpertReviewUncheckedCreateInput>
  }

  /**
   * ExpertReview createMany
   */
  export type ExpertReviewCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ExpertReviews.
     */
    data: ExpertReviewCreateManyInput | ExpertReviewCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ExpertReview createManyAndReturn
   */
  export type ExpertReviewCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ExpertReviews.
     */
    data: ExpertReviewCreateManyInput | ExpertReviewCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ExpertReview update
   */
  export type ExpertReviewUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * The data needed to update a ExpertReview.
     */
    data: XOR<ExpertReviewUpdateInput, ExpertReviewUncheckedUpdateInput>
    /**
     * Choose, which ExpertReview to update.
     */
    where: ExpertReviewWhereUniqueInput
  }

  /**
   * ExpertReview updateMany
   */
  export type ExpertReviewUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ExpertReviews.
     */
    data: XOR<ExpertReviewUpdateManyMutationInput, ExpertReviewUncheckedUpdateManyInput>
    /**
     * Filter which ExpertReviews to update
     */
    where?: ExpertReviewWhereInput
  }

  /**
   * ExpertReview upsert
   */
  export type ExpertReviewUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * The filter to search for the ExpertReview to update in case it exists.
     */
    where: ExpertReviewWhereUniqueInput
    /**
     * In case the ExpertReview found by the `where` argument doesn't exist, create a new ExpertReview with this data.
     */
    create: XOR<ExpertReviewCreateInput, ExpertReviewUncheckedCreateInput>
    /**
     * In case the ExpertReview was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExpertReviewUpdateInput, ExpertReviewUncheckedUpdateInput>
  }

  /**
   * ExpertReview delete
   */
  export type ExpertReviewDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
    /**
     * Filter which ExpertReview to delete.
     */
    where: ExpertReviewWhereUniqueInput
  }

  /**
   * ExpertReview deleteMany
   */
  export type ExpertReviewDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExpertReviews to delete
     */
    where?: ExpertReviewWhereInput
  }

  /**
   * ExpertReview without action
   */
  export type ExpertReviewDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertReview
     */
    select?: ExpertReviewSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExpertReviewInclude<ExtArgs> | null
  }


  /**
   * Model admin_invite_experts
   */

  export type AggregateAdmin_invite_experts = {
    _count: Admin_invite_expertsCountAggregateOutputType | null
    _min: Admin_invite_expertsMinAggregateOutputType | null
    _max: Admin_invite_expertsMaxAggregateOutputType | null
  }

  export type Admin_invite_expertsMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    created_at: Date | null
    email: string | null
    status: $Enums.INVITE_STATUS | null
  }

  export type Admin_invite_expertsMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    created_at: Date | null
    email: string | null
    status: $Enums.INVITE_STATUS | null
  }

  export type Admin_invite_expertsCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    created_at: number
    email: number
    status: number
    _all: number
  }


  export type Admin_invite_expertsMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    created_at?: true
    email?: true
    status?: true
  }

  export type Admin_invite_expertsMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    created_at?: true
    email?: true
    status?: true
  }

  export type Admin_invite_expertsCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    created_at?: true
    email?: true
    status?: true
    _all?: true
  }

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

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




  export type admin_invite_expertsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_invite_expertsWhereInput
    orderBy?: admin_invite_expertsOrderByWithAggregationInput | admin_invite_expertsOrderByWithAggregationInput[]
    by: Admin_invite_expertsScalarFieldEnum[] | Admin_invite_expertsScalarFieldEnum
    having?: admin_invite_expertsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_invite_expertsCountAggregateInputType | true
    _min?: Admin_invite_expertsMinAggregateInputType
    _max?: Admin_invite_expertsMaxAggregateInputType
  }

  export type Admin_invite_expertsGroupByOutputType = {
    id: string
    firstName: string | null
    lastName: string | null
    created_at: Date
    email: string | null
    status: $Enums.INVITE_STATUS
    _count: Admin_invite_expertsCountAggregateOutputType | null
    _min: Admin_invite_expertsMinAggregateOutputType | null
    _max: Admin_invite_expertsMaxAggregateOutputType | null
  }

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


  export type admin_invite_expertsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    created_at?: boolean
    email?: boolean
    status?: boolean
  }, ExtArgs["result"]["admin_invite_experts"]>

  export type admin_invite_expertsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    created_at?: boolean
    email?: boolean
    status?: boolean
  }, ExtArgs["result"]["admin_invite_experts"]>

  export type admin_invite_expertsSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    created_at?: boolean
    email?: boolean
    status?: boolean
  }


  export type $admin_invite_expertsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_invite_experts"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string | null
      lastName: string | null
      created_at: Date
      email: string | null
      status: $Enums.INVITE_STATUS
    }, ExtArgs["result"]["admin_invite_experts"]>
    composites: {}
  }

  type admin_invite_expertsGetPayload<S extends boolean | null | undefined | admin_invite_expertsDefaultArgs> = $Result.GetResult<Prisma.$admin_invite_expertsPayload, S>

  type admin_invite_expertsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_invite_expertsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_invite_expertsCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_invite_experts 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 {admin_invite_expertsFindFirstArgs} args - Arguments to find a Admin_invite_experts
     * @example
     * // Get one Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_invite_expertsFindFirstArgs>(args?: SelectSubset<T, admin_invite_expertsFindFirstArgs<ExtArgs>>): Prisma__admin_invite_expertsClient<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_invite_experts 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 {admin_invite_expertsFindFirstOrThrowArgs} args - Arguments to find a Admin_invite_experts
     * @example
     * // Get one Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_invite_expertsFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_invite_expertsFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_invite_expertsClient<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_invite_experts 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 {admin_invite_expertsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.findMany()
     * 
     * // Get first 10 Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_invite_expertsWithIdOnly = await prisma.admin_invite_experts.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_invite_expertsFindManyArgs>(args?: SelectSubset<T, admin_invite_expertsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_invite_experts.
     * @param {admin_invite_expertsCreateArgs} args - Arguments to create a Admin_invite_experts.
     * @example
     * // Create one Admin_invite_experts
     * const Admin_invite_experts = await prisma.admin_invite_experts.create({
     *   data: {
     *     // ... data to create a Admin_invite_experts
     *   }
     * })
     * 
     */
    create<T extends admin_invite_expertsCreateArgs>(args: SelectSubset<T, admin_invite_expertsCreateArgs<ExtArgs>>): Prisma__admin_invite_expertsClient<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_invite_experts and returns the data saved in the database.
     * @param {admin_invite_expertsCreateManyAndReturnArgs} args - Arguments to create many Admin_invite_experts.
     * @example
     * // Create many Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_invite_experts and only return the `id`
     * const admin_invite_expertsWithIdOnly = await prisma.admin_invite_experts.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_invite_expertsCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_invite_expertsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_invite_experts.
     * @param {admin_invite_expertsDeleteArgs} args - Arguments to delete one Admin_invite_experts.
     * @example
     * // Delete one Admin_invite_experts
     * const Admin_invite_experts = await prisma.admin_invite_experts.delete({
     *   where: {
     *     // ... filter to delete one Admin_invite_experts
     *   }
     * })
     * 
     */
    delete<T extends admin_invite_expertsDeleteArgs>(args: SelectSubset<T, admin_invite_expertsDeleteArgs<ExtArgs>>): Prisma__admin_invite_expertsClient<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_invite_experts.
     * @param {admin_invite_expertsUpdateArgs} args - Arguments to update one Admin_invite_experts.
     * @example
     * // Update one Admin_invite_experts
     * const admin_invite_experts = await prisma.admin_invite_experts.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_invite_expertsUpdateArgs>(args: SelectSubset<T, admin_invite_expertsUpdateArgs<ExtArgs>>): Prisma__admin_invite_expertsClient<$Result.GetResult<Prisma.$admin_invite_expertsPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_invite_experts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_invite_expertsGroupByArgs} 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 admin_invite_expertsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_invite_expertsGroupByArgs['orderBy'] }
        : { orderBy?: admin_invite_expertsGroupByArgs['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, admin_invite_expertsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_invite_expertsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_invite_experts model
   */
  readonly fields: admin_invite_expertsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_invite_experts.
   * 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__admin_invite_expertsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_invite_experts model
   */ 
  interface admin_invite_expertsFieldRefs {
    readonly id: FieldRef<"admin_invite_experts", 'String'>
    readonly firstName: FieldRef<"admin_invite_experts", 'String'>
    readonly lastName: FieldRef<"admin_invite_experts", 'String'>
    readonly created_at: FieldRef<"admin_invite_experts", 'DateTime'>
    readonly email: FieldRef<"admin_invite_experts", 'String'>
    readonly status: FieldRef<"admin_invite_experts", 'INVITE_STATUS'>
  }
    

  // Custom InputTypes
  /**
   * admin_invite_experts findUnique
   */
  export type admin_invite_expertsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * Filter, which admin_invite_experts to fetch.
     */
    where: admin_invite_expertsWhereUniqueInput
  }

  /**
   * admin_invite_experts findUniqueOrThrow
   */
  export type admin_invite_expertsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * Filter, which admin_invite_experts to fetch.
     */
    where: admin_invite_expertsWhereUniqueInput
  }

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

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

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

  /**
   * admin_invite_experts create
   */
  export type admin_invite_expertsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_invite_experts.
     */
    data: XOR<admin_invite_expertsCreateInput, admin_invite_expertsUncheckedCreateInput>
  }

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

  /**
   * admin_invite_experts createManyAndReturn
   */
  export type admin_invite_expertsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_invite_experts.
     */
    data: admin_invite_expertsCreateManyInput | admin_invite_expertsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_invite_experts update
   */
  export type admin_invite_expertsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_invite_experts.
     */
    data: XOR<admin_invite_expertsUpdateInput, admin_invite_expertsUncheckedUpdateInput>
    /**
     * Choose, which admin_invite_experts to update.
     */
    where: admin_invite_expertsWhereUniqueInput
  }

  /**
   * admin_invite_experts updateMany
   */
  export type admin_invite_expertsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_invite_experts.
     */
    data: XOR<admin_invite_expertsUpdateManyMutationInput, admin_invite_expertsUncheckedUpdateManyInput>
    /**
     * Filter which admin_invite_experts to update
     */
    where?: admin_invite_expertsWhereInput
  }

  /**
   * admin_invite_experts upsert
   */
  export type admin_invite_expertsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_invite_experts to update in case it exists.
     */
    where: admin_invite_expertsWhereUniqueInput
    /**
     * In case the admin_invite_experts found by the `where` argument doesn't exist, create a new admin_invite_experts with this data.
     */
    create: XOR<admin_invite_expertsCreateInput, admin_invite_expertsUncheckedCreateInput>
    /**
     * In case the admin_invite_experts was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_invite_expertsUpdateInput, admin_invite_expertsUncheckedUpdateInput>
  }

  /**
   * admin_invite_experts delete
   */
  export type admin_invite_expertsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
    /**
     * Filter which admin_invite_experts to delete.
     */
    where: admin_invite_expertsWhereUniqueInput
  }

  /**
   * admin_invite_experts deleteMany
   */
  export type admin_invite_expertsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_invite_experts to delete
     */
    where?: admin_invite_expertsWhereInput
  }

  /**
   * admin_invite_experts without action
   */
  export type admin_invite_expertsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_invite_experts
     */
    select?: admin_invite_expertsSelect<ExtArgs> | null
  }


  /**
   * Model admin_mbc_cms
   */

  export type AggregateAdmin_mbc_cms = {
    _count: Admin_mbc_cmsCountAggregateOutputType | null
    _avg: Admin_mbc_cmsAvgAggregateOutputType | null
    _sum: Admin_mbc_cmsSumAggregateOutputType | null
    _min: Admin_mbc_cmsMinAggregateOutputType | null
    _max: Admin_mbc_cmsMaxAggregateOutputType | null
  }

  export type Admin_mbc_cmsAvgAggregateOutputType = {
    id: number | null
    is_active: number | null
  }

  export type Admin_mbc_cmsSumAggregateOutputType = {
    id: bigint | null
    is_active: number | null
  }

  export type Admin_mbc_cmsMinAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    section1_text: string | null
    section1_image: string | null
    section2_text: string | null
    section2_image: string | null
    about_us_title: string | null
    about_us_desc: string | null
    general_condition_of_use: string | null
    general_condition_of_sales: string | null
    is_active: number | null
    invite_email_content: string | null
    invite_email_subject: string | null
  }

  export type Admin_mbc_cmsMaxAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    section1_text: string | null
    section1_image: string | null
    section2_text: string | null
    section2_image: string | null
    about_us_title: string | null
    about_us_desc: string | null
    general_condition_of_use: string | null
    general_condition_of_sales: string | null
    is_active: number | null
    invite_email_content: string | null
    invite_email_subject: string | null
  }

  export type Admin_mbc_cmsCountAggregateOutputType = {
    id: number
    created_at: number
    section1_text: number
    section1_image: number
    section2_text: number
    section2_image: number
    about_us_title: number
    about_us_desc: number
    general_condition_of_use: number
    general_condition_of_sales: number
    is_active: number
    invite_email_content: number
    invite_email_subject: number
    _all: number
  }


  export type Admin_mbc_cmsAvgAggregateInputType = {
    id?: true
    is_active?: true
  }

  export type Admin_mbc_cmsSumAggregateInputType = {
    id?: true
    is_active?: true
  }

  export type Admin_mbc_cmsMinAggregateInputType = {
    id?: true
    created_at?: true
    section1_text?: true
    section1_image?: true
    section2_text?: true
    section2_image?: true
    about_us_title?: true
    about_us_desc?: true
    general_condition_of_use?: true
    general_condition_of_sales?: true
    is_active?: true
    invite_email_content?: true
    invite_email_subject?: true
  }

  export type Admin_mbc_cmsMaxAggregateInputType = {
    id?: true
    created_at?: true
    section1_text?: true
    section1_image?: true
    section2_text?: true
    section2_image?: true
    about_us_title?: true
    about_us_desc?: true
    general_condition_of_use?: true
    general_condition_of_sales?: true
    is_active?: true
    invite_email_content?: true
    invite_email_subject?: true
  }

  export type Admin_mbc_cmsCountAggregateInputType = {
    id?: true
    created_at?: true
    section1_text?: true
    section1_image?: true
    section2_text?: true
    section2_image?: true
    about_us_title?: true
    about_us_desc?: true
    general_condition_of_use?: true
    general_condition_of_sales?: true
    is_active?: true
    invite_email_content?: true
    invite_email_subject?: true
    _all?: true
  }

  export type Admin_mbc_cmsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_mbc_cms to aggregate.
     */
    where?: admin_mbc_cmsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_mbc_cms to fetch.
     */
    orderBy?: admin_mbc_cmsOrderByWithRelationInput | admin_mbc_cmsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_mbc_cmsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_mbc_cms 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` admin_mbc_cms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_mbc_cms
    **/
    _count?: true | Admin_mbc_cmsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_mbc_cmsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_mbc_cmsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_mbc_cmsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_mbc_cmsMaxAggregateInputType
  }

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




  export type admin_mbc_cmsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_mbc_cmsWhereInput
    orderBy?: admin_mbc_cmsOrderByWithAggregationInput | admin_mbc_cmsOrderByWithAggregationInput[]
    by: Admin_mbc_cmsScalarFieldEnum[] | Admin_mbc_cmsScalarFieldEnum
    having?: admin_mbc_cmsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_mbc_cmsCountAggregateInputType | true
    _avg?: Admin_mbc_cmsAvgAggregateInputType
    _sum?: Admin_mbc_cmsSumAggregateInputType
    _min?: Admin_mbc_cmsMinAggregateInputType
    _max?: Admin_mbc_cmsMaxAggregateInputType
  }

  export type Admin_mbc_cmsGroupByOutputType = {
    id: bigint
    created_at: Date
    section1_text: string | null
    section1_image: string | null
    section2_text: string | null
    section2_image: string | null
    about_us_title: string | null
    about_us_desc: string | null
    general_condition_of_use: string | null
    general_condition_of_sales: string | null
    is_active: number | null
    invite_email_content: string | null
    invite_email_subject: string | null
    _count: Admin_mbc_cmsCountAggregateOutputType | null
    _avg: Admin_mbc_cmsAvgAggregateOutputType | null
    _sum: Admin_mbc_cmsSumAggregateOutputType | null
    _min: Admin_mbc_cmsMinAggregateOutputType | null
    _max: Admin_mbc_cmsMaxAggregateOutputType | null
  }

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


  export type admin_mbc_cmsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    section1_text?: boolean
    section1_image?: boolean
    section2_text?: boolean
    section2_image?: boolean
    about_us_title?: boolean
    about_us_desc?: boolean
    general_condition_of_use?: boolean
    general_condition_of_sales?: boolean
    is_active?: boolean
    invite_email_content?: boolean
    invite_email_subject?: boolean
  }, ExtArgs["result"]["admin_mbc_cms"]>

  export type admin_mbc_cmsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    section1_text?: boolean
    section1_image?: boolean
    section2_text?: boolean
    section2_image?: boolean
    about_us_title?: boolean
    about_us_desc?: boolean
    general_condition_of_use?: boolean
    general_condition_of_sales?: boolean
    is_active?: boolean
    invite_email_content?: boolean
    invite_email_subject?: boolean
  }, ExtArgs["result"]["admin_mbc_cms"]>

  export type admin_mbc_cmsSelectScalar = {
    id?: boolean
    created_at?: boolean
    section1_text?: boolean
    section1_image?: boolean
    section2_text?: boolean
    section2_image?: boolean
    about_us_title?: boolean
    about_us_desc?: boolean
    general_condition_of_use?: boolean
    general_condition_of_sales?: boolean
    is_active?: boolean
    invite_email_content?: boolean
    invite_email_subject?: boolean
  }


  export type $admin_mbc_cmsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_mbc_cms"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: bigint
      created_at: Date
      section1_text: string | null
      section1_image: string | null
      section2_text: string | null
      section2_image: string | null
      about_us_title: string | null
      about_us_desc: string | null
      general_condition_of_use: string | null
      general_condition_of_sales: string | null
      is_active: number | null
      invite_email_content: string | null
      invite_email_subject: string | null
    }, ExtArgs["result"]["admin_mbc_cms"]>
    composites: {}
  }

  type admin_mbc_cmsGetPayload<S extends boolean | null | undefined | admin_mbc_cmsDefaultArgs> = $Result.GetResult<Prisma.$admin_mbc_cmsPayload, S>

  type admin_mbc_cmsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_mbc_cmsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_mbc_cmsCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_mbc_cms 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 {admin_mbc_cmsFindFirstArgs} args - Arguments to find a Admin_mbc_cms
     * @example
     * // Get one Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_mbc_cmsFindFirstArgs>(args?: SelectSubset<T, admin_mbc_cmsFindFirstArgs<ExtArgs>>): Prisma__admin_mbc_cmsClient<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_mbc_cms 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 {admin_mbc_cmsFindFirstOrThrowArgs} args - Arguments to find a Admin_mbc_cms
     * @example
     * // Get one Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_mbc_cmsFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_mbc_cmsFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_mbc_cmsClient<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_mbc_cms 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 {admin_mbc_cmsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.findMany()
     * 
     * // Get first 10 Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_mbc_cmsWithIdOnly = await prisma.admin_mbc_cms.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_mbc_cmsFindManyArgs>(args?: SelectSubset<T, admin_mbc_cmsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_mbc_cms.
     * @param {admin_mbc_cmsCreateArgs} args - Arguments to create a Admin_mbc_cms.
     * @example
     * // Create one Admin_mbc_cms
     * const Admin_mbc_cms = await prisma.admin_mbc_cms.create({
     *   data: {
     *     // ... data to create a Admin_mbc_cms
     *   }
     * })
     * 
     */
    create<T extends admin_mbc_cmsCreateArgs>(args: SelectSubset<T, admin_mbc_cmsCreateArgs<ExtArgs>>): Prisma__admin_mbc_cmsClient<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_mbc_cms and returns the data saved in the database.
     * @param {admin_mbc_cmsCreateManyAndReturnArgs} args - Arguments to create many Admin_mbc_cms.
     * @example
     * // Create many Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_mbc_cms and only return the `id`
     * const admin_mbc_cmsWithIdOnly = await prisma.admin_mbc_cms.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_mbc_cmsCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_mbc_cmsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_mbc_cms.
     * @param {admin_mbc_cmsDeleteArgs} args - Arguments to delete one Admin_mbc_cms.
     * @example
     * // Delete one Admin_mbc_cms
     * const Admin_mbc_cms = await prisma.admin_mbc_cms.delete({
     *   where: {
     *     // ... filter to delete one Admin_mbc_cms
     *   }
     * })
     * 
     */
    delete<T extends admin_mbc_cmsDeleteArgs>(args: SelectSubset<T, admin_mbc_cmsDeleteArgs<ExtArgs>>): Prisma__admin_mbc_cmsClient<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_mbc_cms.
     * @param {admin_mbc_cmsUpdateArgs} args - Arguments to update one Admin_mbc_cms.
     * @example
     * // Update one Admin_mbc_cms
     * const admin_mbc_cms = await prisma.admin_mbc_cms.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_mbc_cmsUpdateArgs>(args: SelectSubset<T, admin_mbc_cmsUpdateArgs<ExtArgs>>): Prisma__admin_mbc_cmsClient<$Result.GetResult<Prisma.$admin_mbc_cmsPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_mbc_cms.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_mbc_cmsGroupByArgs} 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 admin_mbc_cmsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_mbc_cmsGroupByArgs['orderBy'] }
        : { orderBy?: admin_mbc_cmsGroupByArgs['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, admin_mbc_cmsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_mbc_cmsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_mbc_cms model
   */
  readonly fields: admin_mbc_cmsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_mbc_cms.
   * 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__admin_mbc_cmsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_mbc_cms model
   */ 
  interface admin_mbc_cmsFieldRefs {
    readonly id: FieldRef<"admin_mbc_cms", 'BigInt'>
    readonly created_at: FieldRef<"admin_mbc_cms", 'DateTime'>
    readonly section1_text: FieldRef<"admin_mbc_cms", 'String'>
    readonly section1_image: FieldRef<"admin_mbc_cms", 'String'>
    readonly section2_text: FieldRef<"admin_mbc_cms", 'String'>
    readonly section2_image: FieldRef<"admin_mbc_cms", 'String'>
    readonly about_us_title: FieldRef<"admin_mbc_cms", 'String'>
    readonly about_us_desc: FieldRef<"admin_mbc_cms", 'String'>
    readonly general_condition_of_use: FieldRef<"admin_mbc_cms", 'String'>
    readonly general_condition_of_sales: FieldRef<"admin_mbc_cms", 'String'>
    readonly is_active: FieldRef<"admin_mbc_cms", 'Int'>
    readonly invite_email_content: FieldRef<"admin_mbc_cms", 'String'>
    readonly invite_email_subject: FieldRef<"admin_mbc_cms", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_mbc_cms findUnique
   */
  export type admin_mbc_cmsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * Filter, which admin_mbc_cms to fetch.
     */
    where: admin_mbc_cmsWhereUniqueInput
  }

  /**
   * admin_mbc_cms findUniqueOrThrow
   */
  export type admin_mbc_cmsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * Filter, which admin_mbc_cms to fetch.
     */
    where: admin_mbc_cmsWhereUniqueInput
  }

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

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

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

  /**
   * admin_mbc_cms create
   */
  export type admin_mbc_cmsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_mbc_cms.
     */
    data?: XOR<admin_mbc_cmsCreateInput, admin_mbc_cmsUncheckedCreateInput>
  }

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

  /**
   * admin_mbc_cms createManyAndReturn
   */
  export type admin_mbc_cmsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_mbc_cms.
     */
    data: admin_mbc_cmsCreateManyInput | admin_mbc_cmsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_mbc_cms update
   */
  export type admin_mbc_cmsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_mbc_cms.
     */
    data: XOR<admin_mbc_cmsUpdateInput, admin_mbc_cmsUncheckedUpdateInput>
    /**
     * Choose, which admin_mbc_cms to update.
     */
    where: admin_mbc_cmsWhereUniqueInput
  }

  /**
   * admin_mbc_cms updateMany
   */
  export type admin_mbc_cmsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_mbc_cms.
     */
    data: XOR<admin_mbc_cmsUpdateManyMutationInput, admin_mbc_cmsUncheckedUpdateManyInput>
    /**
     * Filter which admin_mbc_cms to update
     */
    where?: admin_mbc_cmsWhereInput
  }

  /**
   * admin_mbc_cms upsert
   */
  export type admin_mbc_cmsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_mbc_cms to update in case it exists.
     */
    where: admin_mbc_cmsWhereUniqueInput
    /**
     * In case the admin_mbc_cms found by the `where` argument doesn't exist, create a new admin_mbc_cms with this data.
     */
    create: XOR<admin_mbc_cmsCreateInput, admin_mbc_cmsUncheckedCreateInput>
    /**
     * In case the admin_mbc_cms was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_mbc_cmsUpdateInput, admin_mbc_cmsUncheckedUpdateInput>
  }

  /**
   * admin_mbc_cms delete
   */
  export type admin_mbc_cmsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
    /**
     * Filter which admin_mbc_cms to delete.
     */
    where: admin_mbc_cmsWhereUniqueInput
  }

  /**
   * admin_mbc_cms deleteMany
   */
  export type admin_mbc_cmsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_mbc_cms to delete
     */
    where?: admin_mbc_cmsWhereInput
  }

  /**
   * admin_mbc_cms without action
   */
  export type admin_mbc_cmsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_cms
     */
    select?: admin_mbc_cmsSelect<ExtArgs> | null
  }


  /**
   * Model admin_mbc_faqs
   */

  export type AggregateAdmin_mbc_faqs = {
    _count: Admin_mbc_faqsCountAggregateOutputType | null
    _avg: Admin_mbc_faqsAvgAggregateOutputType | null
    _sum: Admin_mbc_faqsSumAggregateOutputType | null
    _min: Admin_mbc_faqsMinAggregateOutputType | null
    _max: Admin_mbc_faqsMaxAggregateOutputType | null
  }

  export type Admin_mbc_faqsAvgAggregateOutputType = {
    id: number | null
  }

  export type Admin_mbc_faqsSumAggregateOutputType = {
    id: bigint | null
  }

  export type Admin_mbc_faqsMinAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    question_title: string | null
    question_desc: string | null
  }

  export type Admin_mbc_faqsMaxAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    question_title: string | null
    question_desc: string | null
  }

  export type Admin_mbc_faqsCountAggregateOutputType = {
    id: number
    created_at: number
    question_title: number
    question_desc: number
    _all: number
  }


  export type Admin_mbc_faqsAvgAggregateInputType = {
    id?: true
  }

  export type Admin_mbc_faqsSumAggregateInputType = {
    id?: true
  }

  export type Admin_mbc_faqsMinAggregateInputType = {
    id?: true
    created_at?: true
    question_title?: true
    question_desc?: true
  }

  export type Admin_mbc_faqsMaxAggregateInputType = {
    id?: true
    created_at?: true
    question_title?: true
    question_desc?: true
  }

  export type Admin_mbc_faqsCountAggregateInputType = {
    id?: true
    created_at?: true
    question_title?: true
    question_desc?: true
    _all?: true
  }

  export type Admin_mbc_faqsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_mbc_faqs to aggregate.
     */
    where?: admin_mbc_faqsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_mbc_faqs to fetch.
     */
    orderBy?: admin_mbc_faqsOrderByWithRelationInput | admin_mbc_faqsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_mbc_faqsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_mbc_faqs 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` admin_mbc_faqs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_mbc_faqs
    **/
    _count?: true | Admin_mbc_faqsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_mbc_faqsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_mbc_faqsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_mbc_faqsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_mbc_faqsMaxAggregateInputType
  }

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




  export type admin_mbc_faqsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_mbc_faqsWhereInput
    orderBy?: admin_mbc_faqsOrderByWithAggregationInput | admin_mbc_faqsOrderByWithAggregationInput[]
    by: Admin_mbc_faqsScalarFieldEnum[] | Admin_mbc_faqsScalarFieldEnum
    having?: admin_mbc_faqsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_mbc_faqsCountAggregateInputType | true
    _avg?: Admin_mbc_faqsAvgAggregateInputType
    _sum?: Admin_mbc_faqsSumAggregateInputType
    _min?: Admin_mbc_faqsMinAggregateInputType
    _max?: Admin_mbc_faqsMaxAggregateInputType
  }

  export type Admin_mbc_faqsGroupByOutputType = {
    id: bigint
    created_at: Date
    question_title: string | null
    question_desc: string | null
    _count: Admin_mbc_faqsCountAggregateOutputType | null
    _avg: Admin_mbc_faqsAvgAggregateOutputType | null
    _sum: Admin_mbc_faqsSumAggregateOutputType | null
    _min: Admin_mbc_faqsMinAggregateOutputType | null
    _max: Admin_mbc_faqsMaxAggregateOutputType | null
  }

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


  export type admin_mbc_faqsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    question_title?: boolean
    question_desc?: boolean
  }, ExtArgs["result"]["admin_mbc_faqs"]>

  export type admin_mbc_faqsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    question_title?: boolean
    question_desc?: boolean
  }, ExtArgs["result"]["admin_mbc_faqs"]>

  export type admin_mbc_faqsSelectScalar = {
    id?: boolean
    created_at?: boolean
    question_title?: boolean
    question_desc?: boolean
  }


  export type $admin_mbc_faqsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_mbc_faqs"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: bigint
      created_at: Date
      question_title: string | null
      question_desc: string | null
    }, ExtArgs["result"]["admin_mbc_faqs"]>
    composites: {}
  }

  type admin_mbc_faqsGetPayload<S extends boolean | null | undefined | admin_mbc_faqsDefaultArgs> = $Result.GetResult<Prisma.$admin_mbc_faqsPayload, S>

  type admin_mbc_faqsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_mbc_faqsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_mbc_faqsCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_mbc_faqs 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 {admin_mbc_faqsFindFirstArgs} args - Arguments to find a Admin_mbc_faqs
     * @example
     * // Get one Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_mbc_faqsFindFirstArgs>(args?: SelectSubset<T, admin_mbc_faqsFindFirstArgs<ExtArgs>>): Prisma__admin_mbc_faqsClient<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_mbc_faqs 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 {admin_mbc_faqsFindFirstOrThrowArgs} args - Arguments to find a Admin_mbc_faqs
     * @example
     * // Get one Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_mbc_faqsFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_mbc_faqsFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_mbc_faqsClient<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_mbc_faqs 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 {admin_mbc_faqsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.findMany()
     * 
     * // Get first 10 Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_mbc_faqsWithIdOnly = await prisma.admin_mbc_faqs.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_mbc_faqsFindManyArgs>(args?: SelectSubset<T, admin_mbc_faqsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_mbc_faqs.
     * @param {admin_mbc_faqsCreateArgs} args - Arguments to create a Admin_mbc_faqs.
     * @example
     * // Create one Admin_mbc_faqs
     * const Admin_mbc_faqs = await prisma.admin_mbc_faqs.create({
     *   data: {
     *     // ... data to create a Admin_mbc_faqs
     *   }
     * })
     * 
     */
    create<T extends admin_mbc_faqsCreateArgs>(args: SelectSubset<T, admin_mbc_faqsCreateArgs<ExtArgs>>): Prisma__admin_mbc_faqsClient<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_mbc_faqs and returns the data saved in the database.
     * @param {admin_mbc_faqsCreateManyAndReturnArgs} args - Arguments to create many Admin_mbc_faqs.
     * @example
     * // Create many Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_mbc_faqs and only return the `id`
     * const admin_mbc_faqsWithIdOnly = await prisma.admin_mbc_faqs.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_mbc_faqsCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_mbc_faqsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_mbc_faqs.
     * @param {admin_mbc_faqsDeleteArgs} args - Arguments to delete one Admin_mbc_faqs.
     * @example
     * // Delete one Admin_mbc_faqs
     * const Admin_mbc_faqs = await prisma.admin_mbc_faqs.delete({
     *   where: {
     *     // ... filter to delete one Admin_mbc_faqs
     *   }
     * })
     * 
     */
    delete<T extends admin_mbc_faqsDeleteArgs>(args: SelectSubset<T, admin_mbc_faqsDeleteArgs<ExtArgs>>): Prisma__admin_mbc_faqsClient<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_mbc_faqs.
     * @param {admin_mbc_faqsUpdateArgs} args - Arguments to update one Admin_mbc_faqs.
     * @example
     * // Update one Admin_mbc_faqs
     * const admin_mbc_faqs = await prisma.admin_mbc_faqs.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_mbc_faqsUpdateArgs>(args: SelectSubset<T, admin_mbc_faqsUpdateArgs<ExtArgs>>): Prisma__admin_mbc_faqsClient<$Result.GetResult<Prisma.$admin_mbc_faqsPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_mbc_faqs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_mbc_faqsGroupByArgs} 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 admin_mbc_faqsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_mbc_faqsGroupByArgs['orderBy'] }
        : { orderBy?: admin_mbc_faqsGroupByArgs['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, admin_mbc_faqsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_mbc_faqsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_mbc_faqs model
   */
  readonly fields: admin_mbc_faqsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_mbc_faqs.
   * 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__admin_mbc_faqsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_mbc_faqs model
   */ 
  interface admin_mbc_faqsFieldRefs {
    readonly id: FieldRef<"admin_mbc_faqs", 'BigInt'>
    readonly created_at: FieldRef<"admin_mbc_faqs", 'DateTime'>
    readonly question_title: FieldRef<"admin_mbc_faqs", 'String'>
    readonly question_desc: FieldRef<"admin_mbc_faqs", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_mbc_faqs findUnique
   */
  export type admin_mbc_faqsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * Filter, which admin_mbc_faqs to fetch.
     */
    where: admin_mbc_faqsWhereUniqueInput
  }

  /**
   * admin_mbc_faqs findUniqueOrThrow
   */
  export type admin_mbc_faqsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * Filter, which admin_mbc_faqs to fetch.
     */
    where: admin_mbc_faqsWhereUniqueInput
  }

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

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

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

  /**
   * admin_mbc_faqs create
   */
  export type admin_mbc_faqsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_mbc_faqs.
     */
    data?: XOR<admin_mbc_faqsCreateInput, admin_mbc_faqsUncheckedCreateInput>
  }

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

  /**
   * admin_mbc_faqs createManyAndReturn
   */
  export type admin_mbc_faqsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_mbc_faqs.
     */
    data: admin_mbc_faqsCreateManyInput | admin_mbc_faqsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_mbc_faqs update
   */
  export type admin_mbc_faqsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_mbc_faqs.
     */
    data: XOR<admin_mbc_faqsUpdateInput, admin_mbc_faqsUncheckedUpdateInput>
    /**
     * Choose, which admin_mbc_faqs to update.
     */
    where: admin_mbc_faqsWhereUniqueInput
  }

  /**
   * admin_mbc_faqs updateMany
   */
  export type admin_mbc_faqsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_mbc_faqs.
     */
    data: XOR<admin_mbc_faqsUpdateManyMutationInput, admin_mbc_faqsUncheckedUpdateManyInput>
    /**
     * Filter which admin_mbc_faqs to update
     */
    where?: admin_mbc_faqsWhereInput
  }

  /**
   * admin_mbc_faqs upsert
   */
  export type admin_mbc_faqsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_mbc_faqs to update in case it exists.
     */
    where: admin_mbc_faqsWhereUniqueInput
    /**
     * In case the admin_mbc_faqs found by the `where` argument doesn't exist, create a new admin_mbc_faqs with this data.
     */
    create: XOR<admin_mbc_faqsCreateInput, admin_mbc_faqsUncheckedCreateInput>
    /**
     * In case the admin_mbc_faqs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_mbc_faqsUpdateInput, admin_mbc_faqsUncheckedUpdateInput>
  }

  /**
   * admin_mbc_faqs delete
   */
  export type admin_mbc_faqsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
    /**
     * Filter which admin_mbc_faqs to delete.
     */
    where: admin_mbc_faqsWhereUniqueInput
  }

  /**
   * admin_mbc_faqs deleteMany
   */
  export type admin_mbc_faqsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_mbc_faqs to delete
     */
    where?: admin_mbc_faqsWhereInput
  }

  /**
   * admin_mbc_faqs without action
   */
  export type admin_mbc_faqsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_mbc_faqs
     */
    select?: admin_mbc_faqsSelect<ExtArgs> | null
  }


  /**
   * Model admin_newsletter
   */

  export type AggregateAdmin_newsletter = {
    _count: Admin_newsletterCountAggregateOutputType | null
    _avg: Admin_newsletterAvgAggregateOutputType | null
    _sum: Admin_newsletterSumAggregateOutputType | null
    _min: Admin_newsletterMinAggregateOutputType | null
    _max: Admin_newsletterMaxAggregateOutputType | null
  }

  export type Admin_newsletterAvgAggregateOutputType = {
    id: number | null
  }

  export type Admin_newsletterSumAggregateOutputType = {
    id: bigint | null
  }

  export type Admin_newsletterMinAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    email: string | null
    isUser: boolean | null
    name: string | null
  }

  export type Admin_newsletterMaxAggregateOutputType = {
    id: bigint | null
    created_at: Date | null
    email: string | null
    isUser: boolean | null
    name: string | null
  }

  export type Admin_newsletterCountAggregateOutputType = {
    id: number
    created_at: number
    email: number
    isUser: number
    name: number
    _all: number
  }


  export type Admin_newsletterAvgAggregateInputType = {
    id?: true
  }

  export type Admin_newsletterSumAggregateInputType = {
    id?: true
  }

  export type Admin_newsletterMinAggregateInputType = {
    id?: true
    created_at?: true
    email?: true
    isUser?: true
    name?: true
  }

  export type Admin_newsletterMaxAggregateInputType = {
    id?: true
    created_at?: true
    email?: true
    isUser?: true
    name?: true
  }

  export type Admin_newsletterCountAggregateInputType = {
    id?: true
    created_at?: true
    email?: true
    isUser?: true
    name?: true
    _all?: true
  }

  export type Admin_newsletterAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_newsletter to aggregate.
     */
    where?: admin_newsletterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_newsletters to fetch.
     */
    orderBy?: admin_newsletterOrderByWithRelationInput | admin_newsletterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_newsletterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_newsletters 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` admin_newsletters.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_newsletters
    **/
    _count?: true | Admin_newsletterCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_newsletterAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_newsletterSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_newsletterMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_newsletterMaxAggregateInputType
  }

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




  export type admin_newsletterGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_newsletterWhereInput
    orderBy?: admin_newsletterOrderByWithAggregationInput | admin_newsletterOrderByWithAggregationInput[]
    by: Admin_newsletterScalarFieldEnum[] | Admin_newsletterScalarFieldEnum
    having?: admin_newsletterScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_newsletterCountAggregateInputType | true
    _avg?: Admin_newsletterAvgAggregateInputType
    _sum?: Admin_newsletterSumAggregateInputType
    _min?: Admin_newsletterMinAggregateInputType
    _max?: Admin_newsletterMaxAggregateInputType
  }

  export type Admin_newsletterGroupByOutputType = {
    id: bigint
    created_at: Date
    email: string | null
    isUser: boolean
    name: string | null
    _count: Admin_newsletterCountAggregateOutputType | null
    _avg: Admin_newsletterAvgAggregateOutputType | null
    _sum: Admin_newsletterSumAggregateOutputType | null
    _min: Admin_newsletterMinAggregateOutputType | null
    _max: Admin_newsletterMaxAggregateOutputType | null
  }

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


  export type admin_newsletterSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    email?: boolean
    isUser?: boolean
    name?: boolean
  }, ExtArgs["result"]["admin_newsletter"]>

  export type admin_newsletterSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    email?: boolean
    isUser?: boolean
    name?: boolean
  }, ExtArgs["result"]["admin_newsletter"]>

  export type admin_newsletterSelectScalar = {
    id?: boolean
    created_at?: boolean
    email?: boolean
    isUser?: boolean
    name?: boolean
  }


  export type $admin_newsletterPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_newsletter"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: bigint
      created_at: Date
      email: string | null
      isUser: boolean
      name: string | null
    }, ExtArgs["result"]["admin_newsletter"]>
    composites: {}
  }

  type admin_newsletterGetPayload<S extends boolean | null | undefined | admin_newsletterDefaultArgs> = $Result.GetResult<Prisma.$admin_newsletterPayload, S>

  type admin_newsletterCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_newsletterFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_newsletterCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_newsletter 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 {admin_newsletterFindFirstArgs} args - Arguments to find a Admin_newsletter
     * @example
     * // Get one Admin_newsletter
     * const admin_newsletter = await prisma.admin_newsletter.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_newsletterFindFirstArgs>(args?: SelectSubset<T, admin_newsletterFindFirstArgs<ExtArgs>>): Prisma__admin_newsletterClient<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_newsletter 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 {admin_newsletterFindFirstOrThrowArgs} args - Arguments to find a Admin_newsletter
     * @example
     * // Get one Admin_newsletter
     * const admin_newsletter = await prisma.admin_newsletter.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_newsletterFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_newsletterFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_newsletterClient<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_newsletters 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 {admin_newsletterFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_newsletters
     * const admin_newsletters = await prisma.admin_newsletter.findMany()
     * 
     * // Get first 10 Admin_newsletters
     * const admin_newsletters = await prisma.admin_newsletter.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_newsletterWithIdOnly = await prisma.admin_newsletter.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_newsletterFindManyArgs>(args?: SelectSubset<T, admin_newsletterFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_newsletter.
     * @param {admin_newsletterCreateArgs} args - Arguments to create a Admin_newsletter.
     * @example
     * // Create one Admin_newsletter
     * const Admin_newsletter = await prisma.admin_newsletter.create({
     *   data: {
     *     // ... data to create a Admin_newsletter
     *   }
     * })
     * 
     */
    create<T extends admin_newsletterCreateArgs>(args: SelectSubset<T, admin_newsletterCreateArgs<ExtArgs>>): Prisma__admin_newsletterClient<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_newsletters and returns the data saved in the database.
     * @param {admin_newsletterCreateManyAndReturnArgs} args - Arguments to create many Admin_newsletters.
     * @example
     * // Create many Admin_newsletters
     * const admin_newsletter = await prisma.admin_newsletter.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_newsletters and only return the `id`
     * const admin_newsletterWithIdOnly = await prisma.admin_newsletter.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_newsletterCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_newsletterCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_newsletter.
     * @param {admin_newsletterDeleteArgs} args - Arguments to delete one Admin_newsletter.
     * @example
     * // Delete one Admin_newsletter
     * const Admin_newsletter = await prisma.admin_newsletter.delete({
     *   where: {
     *     // ... filter to delete one Admin_newsletter
     *   }
     * })
     * 
     */
    delete<T extends admin_newsletterDeleteArgs>(args: SelectSubset<T, admin_newsletterDeleteArgs<ExtArgs>>): Prisma__admin_newsletterClient<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_newsletter.
     * @param {admin_newsletterUpdateArgs} args - Arguments to update one Admin_newsletter.
     * @example
     * // Update one Admin_newsletter
     * const admin_newsletter = await prisma.admin_newsletter.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_newsletterUpdateArgs>(args: SelectSubset<T, admin_newsletterUpdateArgs<ExtArgs>>): Prisma__admin_newsletterClient<$Result.GetResult<Prisma.$admin_newsletterPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_newsletter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_newsletterGroupByArgs} 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 admin_newsletterGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_newsletterGroupByArgs['orderBy'] }
        : { orderBy?: admin_newsletterGroupByArgs['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, admin_newsletterGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_newsletterGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_newsletter model
   */
  readonly fields: admin_newsletterFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_newsletter.
   * 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__admin_newsletterClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_newsletter model
   */ 
  interface admin_newsletterFieldRefs {
    readonly id: FieldRef<"admin_newsletter", 'BigInt'>
    readonly created_at: FieldRef<"admin_newsletter", 'DateTime'>
    readonly email: FieldRef<"admin_newsletter", 'String'>
    readonly isUser: FieldRef<"admin_newsletter", 'Boolean'>
    readonly name: FieldRef<"admin_newsletter", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_newsletter findUnique
   */
  export type admin_newsletterFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * Filter, which admin_newsletter to fetch.
     */
    where: admin_newsletterWhereUniqueInput
  }

  /**
   * admin_newsletter findUniqueOrThrow
   */
  export type admin_newsletterFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * Filter, which admin_newsletter to fetch.
     */
    where: admin_newsletterWhereUniqueInput
  }

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

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

  /**
   * admin_newsletter findMany
   */
  export type admin_newsletterFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * Filter, which admin_newsletters to fetch.
     */
    where?: admin_newsletterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_newsletters to fetch.
     */
    orderBy?: admin_newsletterOrderByWithRelationInput | admin_newsletterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_newsletters.
     */
    cursor?: admin_newsletterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_newsletters 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` admin_newsletters.
     */
    skip?: number
    distinct?: Admin_newsletterScalarFieldEnum | Admin_newsletterScalarFieldEnum[]
  }

  /**
   * admin_newsletter create
   */
  export type admin_newsletterCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_newsletter.
     */
    data: XOR<admin_newsletterCreateInput, admin_newsletterUncheckedCreateInput>
  }

  /**
   * admin_newsletter createMany
   */
  export type admin_newsletterCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_newsletters.
     */
    data: admin_newsletterCreateManyInput | admin_newsletterCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_newsletter createManyAndReturn
   */
  export type admin_newsletterCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_newsletters.
     */
    data: admin_newsletterCreateManyInput | admin_newsletterCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_newsletter update
   */
  export type admin_newsletterUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_newsletter.
     */
    data: XOR<admin_newsletterUpdateInput, admin_newsletterUncheckedUpdateInput>
    /**
     * Choose, which admin_newsletter to update.
     */
    where: admin_newsletterWhereUniqueInput
  }

  /**
   * admin_newsletter updateMany
   */
  export type admin_newsletterUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_newsletters.
     */
    data: XOR<admin_newsletterUpdateManyMutationInput, admin_newsletterUncheckedUpdateManyInput>
    /**
     * Filter which admin_newsletters to update
     */
    where?: admin_newsletterWhereInput
  }

  /**
   * admin_newsletter upsert
   */
  export type admin_newsletterUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_newsletter to update in case it exists.
     */
    where: admin_newsletterWhereUniqueInput
    /**
     * In case the admin_newsletter found by the `where` argument doesn't exist, create a new admin_newsletter with this data.
     */
    create: XOR<admin_newsletterCreateInput, admin_newsletterUncheckedCreateInput>
    /**
     * In case the admin_newsletter was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_newsletterUpdateInput, admin_newsletterUncheckedUpdateInput>
  }

  /**
   * admin_newsletter delete
   */
  export type admin_newsletterDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
    /**
     * Filter which admin_newsletter to delete.
     */
    where: admin_newsletterWhereUniqueInput
  }

  /**
   * admin_newsletter deleteMany
   */
  export type admin_newsletterDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_newsletters to delete
     */
    where?: admin_newsletterWhereInput
  }

  /**
   * admin_newsletter without action
   */
  export type admin_newsletterDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_newsletter
     */
    select?: admin_newsletterSelect<ExtArgs> | null
  }


  /**
   * Model admin_user
   */

  export type AggregateAdmin_user = {
    _count: Admin_userCountAggregateOutputType | null
    _min: Admin_userMinAggregateOutputType | null
    _max: Admin_userMaxAggregateOutputType | null
  }

  export type Admin_userMinAggregateOutputType = {
    id: string | null
    created_at: Date | null
    role: $Enums.AdminRole | null
    user_id: string | null
  }

  export type Admin_userMaxAggregateOutputType = {
    id: string | null
    created_at: Date | null
    role: $Enums.AdminRole | null
    user_id: string | null
  }

  export type Admin_userCountAggregateOutputType = {
    id: number
    created_at: number
    role: number
    user_id: number
    _all: number
  }


  export type Admin_userMinAggregateInputType = {
    id?: true
    created_at?: true
    role?: true
    user_id?: true
  }

  export type Admin_userMaxAggregateInputType = {
    id?: true
    created_at?: true
    role?: true
    user_id?: true
  }

  export type Admin_userCountAggregateInputType = {
    id?: true
    created_at?: true
    role?: true
    user_id?: true
    _all?: true
  }

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

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




  export type admin_userGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_userWhereInput
    orderBy?: admin_userOrderByWithAggregationInput | admin_userOrderByWithAggregationInput[]
    by: Admin_userScalarFieldEnum[] | Admin_userScalarFieldEnum
    having?: admin_userScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_userCountAggregateInputType | true
    _min?: Admin_userMinAggregateInputType
    _max?: Admin_userMaxAggregateInputType
  }

  export type Admin_userGroupByOutputType = {
    id: string
    created_at: Date
    role: $Enums.AdminRole | null
    user_id: string
    _count: Admin_userCountAggregateOutputType | null
    _min: Admin_userMinAggregateOutputType | null
    _max: Admin_userMaxAggregateOutputType | null
  }

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


  export type admin_userSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    role?: boolean
    user_id?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["admin_user"]>

  export type admin_userSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    role?: boolean
    user_id?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["admin_user"]>

  export type admin_userSelectScalar = {
    id?: boolean
    created_at?: boolean
    role?: boolean
    user_id?: boolean
  }

  export type admin_userInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type admin_userIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $admin_userPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_user"
    objects: {
      User: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      created_at: Date
      role: $Enums.AdminRole | null
      user_id: string
    }, ExtArgs["result"]["admin_user"]>
    composites: {}
  }

  type admin_userGetPayload<S extends boolean | null | undefined | admin_userDefaultArgs> = $Result.GetResult<Prisma.$admin_userPayload, S>

  type admin_userCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_userFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_userCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_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 {admin_userFindFirstArgs} args - Arguments to find a Admin_user
     * @example
     * // Get one Admin_user
     * const admin_user = await prisma.admin_user.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_userFindFirstArgs>(args?: SelectSubset<T, admin_userFindFirstArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_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 {admin_userFindFirstOrThrowArgs} args - Arguments to find a Admin_user
     * @example
     * // Get one Admin_user
     * const admin_user = await prisma.admin_user.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_userFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_userFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_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 {admin_userFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_users
     * const admin_users = await prisma.admin_user.findMany()
     * 
     * // Get first 10 Admin_users
     * const admin_users = await prisma.admin_user.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_userWithIdOnly = await prisma.admin_user.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_userFindManyArgs>(args?: SelectSubset<T, admin_userFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_user.
     * @param {admin_userCreateArgs} args - Arguments to create a Admin_user.
     * @example
     * // Create one Admin_user
     * const Admin_user = await prisma.admin_user.create({
     *   data: {
     *     // ... data to create a Admin_user
     *   }
     * })
     * 
     */
    create<T extends admin_userCreateArgs>(args: SelectSubset<T, admin_userCreateArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_users and returns the data saved in the database.
     * @param {admin_userCreateManyAndReturnArgs} args - Arguments to create many Admin_users.
     * @example
     * // Create many Admin_users
     * const admin_user = await prisma.admin_user.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_users and only return the `id`
     * const admin_userWithIdOnly = await prisma.admin_user.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_userCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_userCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_user.
     * @param {admin_userDeleteArgs} args - Arguments to delete one Admin_user.
     * @example
     * // Delete one Admin_user
     * const Admin_user = await prisma.admin_user.delete({
     *   where: {
     *     // ... filter to delete one Admin_user
     *   }
     * })
     * 
     */
    delete<T extends admin_userDeleteArgs>(args: SelectSubset<T, admin_userDeleteArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_user.
     * @param {admin_userUpdateArgs} args - Arguments to update one Admin_user.
     * @example
     * // Update one Admin_user
     * const admin_user = await prisma.admin_user.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_userUpdateArgs>(args: SelectSubset<T, admin_userUpdateArgs<ExtArgs>>): Prisma__admin_userClient<$Result.GetResult<Prisma.$admin_userPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_user.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_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 admin_userGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_userGroupByArgs['orderBy'] }
        : { orderBy?: admin_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, admin_userGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_userGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_user model
   */
  readonly fields: admin_userFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_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__admin_userClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    /**
     * 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 admin_user model
   */ 
  interface admin_userFieldRefs {
    readonly id: FieldRef<"admin_user", 'String'>
    readonly created_at: FieldRef<"admin_user", 'DateTime'>
    readonly role: FieldRef<"admin_user", 'AdminRole'>
    readonly user_id: FieldRef<"admin_user", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_user findUnique
   */
  export type admin_userFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter, which admin_user to fetch.
     */
    where: admin_userWhereUniqueInput
  }

  /**
   * admin_user findUniqueOrThrow
   */
  export type admin_userFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter, which admin_user to fetch.
     */
    where: admin_userWhereUniqueInput
  }

  /**
   * admin_user findFirst
   */
  export type admin_userFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter, which admin_user to fetch.
     */
    where?: admin_userWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_users to fetch.
     */
    orderBy?: admin_userOrderByWithRelationInput | admin_userOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_users.
     */
    cursor?: admin_userWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_users.
     */
    distinct?: Admin_userScalarFieldEnum | Admin_userScalarFieldEnum[]
  }

  /**
   * admin_user findFirstOrThrow
   */
  export type admin_userFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter, which admin_user to fetch.
     */
    where?: admin_userWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_users to fetch.
     */
    orderBy?: admin_userOrderByWithRelationInput | admin_userOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_users.
     */
    cursor?: admin_userWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_users.
     */
    distinct?: Admin_userScalarFieldEnum | Admin_userScalarFieldEnum[]
  }

  /**
   * admin_user findMany
   */
  export type admin_userFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter, which admin_users to fetch.
     */
    where?: admin_userWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_users to fetch.
     */
    orderBy?: admin_userOrderByWithRelationInput | admin_userOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_users.
     */
    cursor?: admin_userWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_users.
     */
    skip?: number
    distinct?: Admin_userScalarFieldEnum | Admin_userScalarFieldEnum[]
  }

  /**
   * admin_user create
   */
  export type admin_userCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * The data needed to create a admin_user.
     */
    data: XOR<admin_userCreateInput, admin_userUncheckedCreateInput>
  }

  /**
   * admin_user createMany
   */
  export type admin_userCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_users.
     */
    data: admin_userCreateManyInput | admin_userCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_user createManyAndReturn
   */
  export type admin_userCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_users.
     */
    data: admin_userCreateManyInput | admin_userCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * admin_user update
   */
  export type admin_userUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * The data needed to update a admin_user.
     */
    data: XOR<admin_userUpdateInput, admin_userUncheckedUpdateInput>
    /**
     * Choose, which admin_user to update.
     */
    where: admin_userWhereUniqueInput
  }

  /**
   * admin_user updateMany
   */
  export type admin_userUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_users.
     */
    data: XOR<admin_userUpdateManyMutationInput, admin_userUncheckedUpdateManyInput>
    /**
     * Filter which admin_users to update
     */
    where?: admin_userWhereInput
  }

  /**
   * admin_user upsert
   */
  export type admin_userUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * The filter to search for the admin_user to update in case it exists.
     */
    where: admin_userWhereUniqueInput
    /**
     * In case the admin_user found by the `where` argument doesn't exist, create a new admin_user with this data.
     */
    create: XOR<admin_userCreateInput, admin_userUncheckedCreateInput>
    /**
     * In case the admin_user was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_userUpdateInput, admin_userUncheckedUpdateInput>
  }

  /**
   * admin_user delete
   */
  export type admin_userDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
    /**
     * Filter which admin_user to delete.
     */
    where: admin_userWhereUniqueInput
  }

  /**
   * admin_user deleteMany
   */
  export type admin_userDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_users to delete
     */
    where?: admin_userWhereInput
  }

  /**
   * admin_user without action
   */
  export type admin_userDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_user
     */
    select?: admin_userSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_userInclude<ExtArgs> | null
  }


  /**
   * Model faqQuestion
   */

  export type AggregateFaqQuestion = {
    _count: FaqQuestionCountAggregateOutputType | null
    _avg: FaqQuestionAvgAggregateOutputType | null
    _sum: FaqQuestionSumAggregateOutputType | null
    _min: FaqQuestionMinAggregateOutputType | null
    _max: FaqQuestionMaxAggregateOutputType | null
  }

  export type FaqQuestionAvgAggregateOutputType = {
    id: number | null
  }

  export type FaqQuestionSumAggregateOutputType = {
    id: number | null
  }

  export type FaqQuestionMinAggregateOutputType = {
    id: number | null
    question: string | null
    answer: string | null
    created_at: Date | null
  }

  export type FaqQuestionMaxAggregateOutputType = {
    id: number | null
    question: string | null
    answer: string | null
    created_at: Date | null
  }

  export type FaqQuestionCountAggregateOutputType = {
    id: number
    question: number
    answer: number
    created_at: number
    _all: number
  }


  export type FaqQuestionAvgAggregateInputType = {
    id?: true
  }

  export type FaqQuestionSumAggregateInputType = {
    id?: true
  }

  export type FaqQuestionMinAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
  }

  export type FaqQuestionMaxAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
  }

  export type FaqQuestionCountAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
    _all?: true
  }

  export type FaqQuestionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which faqQuestion to aggregate.
     */
    where?: faqQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of faqQuestions to fetch.
     */
    orderBy?: faqQuestionOrderByWithRelationInput | faqQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: faqQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` faqQuestions 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` faqQuestions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned faqQuestions
    **/
    _count?: true | FaqQuestionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FaqQuestionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FaqQuestionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FaqQuestionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FaqQuestionMaxAggregateInputType
  }

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




  export type faqQuestionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: faqQuestionWhereInput
    orderBy?: faqQuestionOrderByWithAggregationInput | faqQuestionOrderByWithAggregationInput[]
    by: FaqQuestionScalarFieldEnum[] | FaqQuestionScalarFieldEnum
    having?: faqQuestionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FaqQuestionCountAggregateInputType | true
    _avg?: FaqQuestionAvgAggregateInputType
    _sum?: FaqQuestionSumAggregateInputType
    _min?: FaqQuestionMinAggregateInputType
    _max?: FaqQuestionMaxAggregateInputType
  }

  export type FaqQuestionGroupByOutputType = {
    id: number
    question: string
    answer: string
    created_at: Date
    _count: FaqQuestionCountAggregateOutputType | null
    _avg: FaqQuestionAvgAggregateOutputType | null
    _sum: FaqQuestionSumAggregateOutputType | null
    _min: FaqQuestionMinAggregateOutputType | null
    _max: FaqQuestionMaxAggregateOutputType | null
  }

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


  export type faqQuestionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    question?: boolean
    answer?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["faqQuestion"]>

  export type faqQuestionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    question?: boolean
    answer?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["faqQuestion"]>

  export type faqQuestionSelectScalar = {
    id?: boolean
    question?: boolean
    answer?: boolean
    created_at?: boolean
  }


  export type $faqQuestionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "faqQuestion"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      question: string
      answer: string
      created_at: Date
    }, ExtArgs["result"]["faqQuestion"]>
    composites: {}
  }

  type faqQuestionGetPayload<S extends boolean | null | undefined | faqQuestionDefaultArgs> = $Result.GetResult<Prisma.$faqQuestionPayload, S>

  type faqQuestionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<faqQuestionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: FaqQuestionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first FaqQuestion 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 {faqQuestionFindFirstArgs} args - Arguments to find a FaqQuestion
     * @example
     * // Get one FaqQuestion
     * const faqQuestion = await prisma.faqQuestion.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends faqQuestionFindFirstArgs>(args?: SelectSubset<T, faqQuestionFindFirstArgs<ExtArgs>>): Prisma__faqQuestionClient<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first FaqQuestion 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 {faqQuestionFindFirstOrThrowArgs} args - Arguments to find a FaqQuestion
     * @example
     * // Get one FaqQuestion
     * const faqQuestion = await prisma.faqQuestion.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends faqQuestionFindFirstOrThrowArgs>(args?: SelectSubset<T, faqQuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma__faqQuestionClient<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more FaqQuestions 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 {faqQuestionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all FaqQuestions
     * const faqQuestions = await prisma.faqQuestion.findMany()
     * 
     * // Get first 10 FaqQuestions
     * const faqQuestions = await prisma.faqQuestion.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const faqQuestionWithIdOnly = await prisma.faqQuestion.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends faqQuestionFindManyArgs>(args?: SelectSubset<T, faqQuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a FaqQuestion.
     * @param {faqQuestionCreateArgs} args - Arguments to create a FaqQuestion.
     * @example
     * // Create one FaqQuestion
     * const FaqQuestion = await prisma.faqQuestion.create({
     *   data: {
     *     // ... data to create a FaqQuestion
     *   }
     * })
     * 
     */
    create<T extends faqQuestionCreateArgs>(args: SelectSubset<T, faqQuestionCreateArgs<ExtArgs>>): Prisma__faqQuestionClient<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many FaqQuestions and returns the data saved in the database.
     * @param {faqQuestionCreateManyAndReturnArgs} args - Arguments to create many FaqQuestions.
     * @example
     * // Create many FaqQuestions
     * const faqQuestion = await prisma.faqQuestion.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many FaqQuestions and only return the `id`
     * const faqQuestionWithIdOnly = await prisma.faqQuestion.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends faqQuestionCreateManyAndReturnArgs>(args?: SelectSubset<T, faqQuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a FaqQuestion.
     * @param {faqQuestionDeleteArgs} args - Arguments to delete one FaqQuestion.
     * @example
     * // Delete one FaqQuestion
     * const FaqQuestion = await prisma.faqQuestion.delete({
     *   where: {
     *     // ... filter to delete one FaqQuestion
     *   }
     * })
     * 
     */
    delete<T extends faqQuestionDeleteArgs>(args: SelectSubset<T, faqQuestionDeleteArgs<ExtArgs>>): Prisma__faqQuestionClient<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one FaqQuestion.
     * @param {faqQuestionUpdateArgs} args - Arguments to update one FaqQuestion.
     * @example
     * // Update one FaqQuestion
     * const faqQuestion = await prisma.faqQuestion.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends faqQuestionUpdateArgs>(args: SelectSubset<T, faqQuestionUpdateArgs<ExtArgs>>): Prisma__faqQuestionClient<$Result.GetResult<Prisma.$faqQuestionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by FaqQuestion.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {faqQuestionGroupByArgs} 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 faqQuestionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: faqQuestionGroupByArgs['orderBy'] }
        : { orderBy?: faqQuestionGroupByArgs['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, faqQuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFaqQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the faqQuestion model
   */
  readonly fields: faqQuestionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for faqQuestion.
   * 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__faqQuestionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 faqQuestion model
   */ 
  interface faqQuestionFieldRefs {
    readonly id: FieldRef<"faqQuestion", 'Int'>
    readonly question: FieldRef<"faqQuestion", 'String'>
    readonly answer: FieldRef<"faqQuestion", 'String'>
    readonly created_at: FieldRef<"faqQuestion", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * faqQuestion findUnique
   */
  export type faqQuestionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * Filter, which faqQuestion to fetch.
     */
    where: faqQuestionWhereUniqueInput
  }

  /**
   * faqQuestion findUniqueOrThrow
   */
  export type faqQuestionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * Filter, which faqQuestion to fetch.
     */
    where: faqQuestionWhereUniqueInput
  }

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

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

  /**
   * faqQuestion findMany
   */
  export type faqQuestionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * Filter, which faqQuestions to fetch.
     */
    where?: faqQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of faqQuestions to fetch.
     */
    orderBy?: faqQuestionOrderByWithRelationInput | faqQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing faqQuestions.
     */
    cursor?: faqQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` faqQuestions 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` faqQuestions.
     */
    skip?: number
    distinct?: FaqQuestionScalarFieldEnum | FaqQuestionScalarFieldEnum[]
  }

  /**
   * faqQuestion create
   */
  export type faqQuestionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * The data needed to create a faqQuestion.
     */
    data: XOR<faqQuestionCreateInput, faqQuestionUncheckedCreateInput>
  }

  /**
   * faqQuestion createMany
   */
  export type faqQuestionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many faqQuestions.
     */
    data: faqQuestionCreateManyInput | faqQuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * faqQuestion createManyAndReturn
   */
  export type faqQuestionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many faqQuestions.
     */
    data: faqQuestionCreateManyInput | faqQuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * faqQuestion update
   */
  export type faqQuestionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * The data needed to update a faqQuestion.
     */
    data: XOR<faqQuestionUpdateInput, faqQuestionUncheckedUpdateInput>
    /**
     * Choose, which faqQuestion to update.
     */
    where: faqQuestionWhereUniqueInput
  }

  /**
   * faqQuestion updateMany
   */
  export type faqQuestionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update faqQuestions.
     */
    data: XOR<faqQuestionUpdateManyMutationInput, faqQuestionUncheckedUpdateManyInput>
    /**
     * Filter which faqQuestions to update
     */
    where?: faqQuestionWhereInput
  }

  /**
   * faqQuestion upsert
   */
  export type faqQuestionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * The filter to search for the faqQuestion to update in case it exists.
     */
    where: faqQuestionWhereUniqueInput
    /**
     * In case the faqQuestion found by the `where` argument doesn't exist, create a new faqQuestion with this data.
     */
    create: XOR<faqQuestionCreateInput, faqQuestionUncheckedCreateInput>
    /**
     * In case the faqQuestion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<faqQuestionUpdateInput, faqQuestionUncheckedUpdateInput>
  }

  /**
   * faqQuestion delete
   */
  export type faqQuestionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
    /**
     * Filter which faqQuestion to delete.
     */
    where: faqQuestionWhereUniqueInput
  }

  /**
   * faqQuestion deleteMany
   */
  export type faqQuestionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which faqQuestions to delete
     */
    where?: faqQuestionWhereInput
  }

  /**
   * faqQuestion without action
   */
  export type faqQuestionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the faqQuestion
     */
    select?: faqQuestionSelect<ExtArgs> | null
  }


  /**
   * Model session
   */

  export type AggregateSession = {
    _count: SessionCountAggregateOutputType | null
    _avg: SessionAvgAggregateOutputType | null
    _sum: SessionSumAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  export type SessionAvgAggregateOutputType = {
    active_expires: number | null
    idle_expires: number | null
  }

  export type SessionSumAggregateOutputType = {
    active_expires: bigint | null
    idle_expires: bigint | null
  }

  export type SessionMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    active_expires: bigint | null
    idle_expires: bigint | null
  }

  export type SessionMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    active_expires: bigint | null
    idle_expires: bigint | null
  }

  export type SessionCountAggregateOutputType = {
    id: number
    user_id: number
    active_expires: number
    idle_expires: number
    _all: number
  }


  export type SessionAvgAggregateInputType = {
    active_expires?: true
    idle_expires?: true
  }

  export type SessionSumAggregateInputType = {
    active_expires?: true
    idle_expires?: true
  }

  export type SessionMinAggregateInputType = {
    id?: true
    user_id?: true
    active_expires?: true
    idle_expires?: true
  }

  export type SessionMaxAggregateInputType = {
    id?: true
    user_id?: true
    active_expires?: true
    idle_expires?: true
  }

  export type SessionCountAggregateInputType = {
    id?: true
    user_id?: true
    active_expires?: true
    idle_expires?: 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 average
    **/
    _avg?: SessionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SessionSumAggregateInputType
    /**
     * {@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
    _avg?: SessionAvgAggregateInputType
    _sum?: SessionSumAggregateInputType
    _min?: SessionMinAggregateInputType
    _max?: SessionMaxAggregateInputType
  }

  export type SessionGroupByOutputType = {
    id: string
    user_id: string
    active_expires: bigint
    idle_expires: bigint
    _count: SessionCountAggregateOutputType | null
    _avg: SessionAvgAggregateOutputType | null
    _sum: SessionSumAggregateOutputType | 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
    user_id?: boolean
    active_expires?: boolean
    idle_expires?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type sessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    active_expires?: boolean
    idle_expires?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type sessionSelectScalar = {
    id?: boolean
    user_id?: boolean
    active_expires?: boolean
    idle_expires?: boolean
  }

  export type sessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type sessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $sessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "session"
    objects: {
      User: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      active_expires: bigint
      idle_expires: bigint
    }, 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'> & {
      select?: SessionCountAggregateInputType | true
    }

  export interface sessionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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"> | null, null, ExtArgs>

    /**
     * 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">, never, ExtArgs>

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

    /**
     * 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">, never, ExtArgs>

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

    /**
     * Create many Sessions and returns the data saved in the database.
     * @param {sessionCreateManyAndReturnArgs} args - Arguments to create many Sessions.
     * @example
     * // Create many Sessions
     * const session = await prisma.session.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Sessions and only return the `id`
     * const sessionWithIdOnly = await prisma.session.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends sessionCreateManyAndReturnArgs>(args?: SelectSubset<T, sessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$sessionPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>

    /**
     * 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">, never, ExtArgs>


    /**
     * 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> 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"> | Null, Null, ExtArgs>
    /**
     * 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 user_id: FieldRef<"session", 'String'>
    readonly active_expires: FieldRef<"session", 'BigInt'>
    readonly idle_expires: FieldRef<"session", 'BigInt'>
  }
    

  // 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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 createManyAndReturn
   */
  export type sessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the session
     */
    select?: sessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many sessions.
     */
    data: sessionCreateManyInput | sessionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * session update
   */
  export type sessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the session
     */
    select?: sessionSelect<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
  }

  /**
   * session upsert
   */
  export type sessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the session
     */
    select?: sessionSelect<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
    /**
     * 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
  }

  /**
   * session without action
   */
  export type sessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the session
     */
    select?: sessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionInclude<ExtArgs> | null
  }


  /**
   * Model admin_editing
   */

  export type AggregateAdmin_editing = {
    _count: Admin_editingCountAggregateOutputType | null
    _avg: Admin_editingAvgAggregateOutputType | null
    _sum: Admin_editingSumAggregateOutputType | null
    _min: Admin_editingMinAggregateOutputType | null
    _max: Admin_editingMaxAggregateOutputType | null
  }

  export type Admin_editingAvgAggregateOutputType = {
    id: number | null
  }

  export type Admin_editingSumAggregateOutputType = {
    id: number | null
  }

  export type Admin_editingMinAggregateOutputType = {
    id: number | null
    updatedAt: Date | null
    genericEmailBody: string | null
    genericEmailHeader: string | null
    aboutContent: string | null
    aboutImageUrl: string | null
    landingPageDesc: string | null
    landingPageHeading: string | null
    landingPageHero: string | null
    landingPageSectionDesc: string | null
    landingPageSectionHeading: string | null
    landingPageSectionHero: string | null
    conditionsSale: string | null
    conditionsUse: string | null
    privacyPolicy: string | null
  }

  export type Admin_editingMaxAggregateOutputType = {
    id: number | null
    updatedAt: Date | null
    genericEmailBody: string | null
    genericEmailHeader: string | null
    aboutContent: string | null
    aboutImageUrl: string | null
    landingPageDesc: string | null
    landingPageHeading: string | null
    landingPageHero: string | null
    landingPageSectionDesc: string | null
    landingPageSectionHeading: string | null
    landingPageSectionHero: string | null
    conditionsSale: string | null
    conditionsUse: string | null
    privacyPolicy: string | null
  }

  export type Admin_editingCountAggregateOutputType = {
    id: number
    updatedAt: number
    genericEmailBody: number
    genericEmailHeader: number
    aboutContent: number
    aboutImageUrl: number
    landingPageDesc: number
    landingPageHeading: number
    landingPageHero: number
    landingPageSectionDesc: number
    landingPageSectionHeading: number
    landingPageSectionHero: number
    conditionsSale: number
    conditionsUse: number
    privacyPolicy: number
    _all: number
  }


  export type Admin_editingAvgAggregateInputType = {
    id?: true
  }

  export type Admin_editingSumAggregateInputType = {
    id?: true
  }

  export type Admin_editingMinAggregateInputType = {
    id?: true
    updatedAt?: true
    genericEmailBody?: true
    genericEmailHeader?: true
    aboutContent?: true
    aboutImageUrl?: true
    landingPageDesc?: true
    landingPageHeading?: true
    landingPageHero?: true
    landingPageSectionDesc?: true
    landingPageSectionHeading?: true
    landingPageSectionHero?: true
    conditionsSale?: true
    conditionsUse?: true
    privacyPolicy?: true
  }

  export type Admin_editingMaxAggregateInputType = {
    id?: true
    updatedAt?: true
    genericEmailBody?: true
    genericEmailHeader?: true
    aboutContent?: true
    aboutImageUrl?: true
    landingPageDesc?: true
    landingPageHeading?: true
    landingPageHero?: true
    landingPageSectionDesc?: true
    landingPageSectionHeading?: true
    landingPageSectionHero?: true
    conditionsSale?: true
    conditionsUse?: true
    privacyPolicy?: true
  }

  export type Admin_editingCountAggregateInputType = {
    id?: true
    updatedAt?: true
    genericEmailBody?: true
    genericEmailHeader?: true
    aboutContent?: true
    aboutImageUrl?: true
    landingPageDesc?: true
    landingPageHeading?: true
    landingPageHero?: true
    landingPageSectionDesc?: true
    landingPageSectionHeading?: true
    landingPageSectionHero?: true
    conditionsSale?: true
    conditionsUse?: true
    privacyPolicy?: true
    _all?: true
  }

  export type Admin_editingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_editing to aggregate.
     */
    where?: admin_editingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_editings to fetch.
     */
    orderBy?: admin_editingOrderByWithRelationInput | admin_editingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_editingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_editings 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` admin_editings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_editings
    **/
    _count?: true | Admin_editingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_editingAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_editingSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_editingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_editingMaxAggregateInputType
  }

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




  export type admin_editingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_editingWhereInput
    orderBy?: admin_editingOrderByWithAggregationInput | admin_editingOrderByWithAggregationInput[]
    by: Admin_editingScalarFieldEnum[] | Admin_editingScalarFieldEnum
    having?: admin_editingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_editingCountAggregateInputType | true
    _avg?: Admin_editingAvgAggregateInputType
    _sum?: Admin_editingSumAggregateInputType
    _min?: Admin_editingMinAggregateInputType
    _max?: Admin_editingMaxAggregateInputType
  }

  export type Admin_editingGroupByOutputType = {
    id: number
    updatedAt: Date
    genericEmailBody: string | null
    genericEmailHeader: string | null
    aboutContent: string | null
    aboutImageUrl: string | null
    landingPageDesc: string | null
    landingPageHeading: string | null
    landingPageHero: string | null
    landingPageSectionDesc: string | null
    landingPageSectionHeading: string | null
    landingPageSectionHero: string | null
    conditionsSale: string | null
    conditionsUse: string | null
    privacyPolicy: string | null
    _count: Admin_editingCountAggregateOutputType | null
    _avg: Admin_editingAvgAggregateOutputType | null
    _sum: Admin_editingSumAggregateOutputType | null
    _min: Admin_editingMinAggregateOutputType | null
    _max: Admin_editingMaxAggregateOutputType | null
  }

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


  export type admin_editingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    updatedAt?: boolean
    genericEmailBody?: boolean
    genericEmailHeader?: boolean
    aboutContent?: boolean
    aboutImageUrl?: boolean
    landingPageDesc?: boolean
    landingPageHeading?: boolean
    landingPageHero?: boolean
    landingPageSectionDesc?: boolean
    landingPageSectionHeading?: boolean
    landingPageSectionHero?: boolean
    conditionsSale?: boolean
    conditionsUse?: boolean
    privacyPolicy?: boolean
  }, ExtArgs["result"]["admin_editing"]>

  export type admin_editingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    updatedAt?: boolean
    genericEmailBody?: boolean
    genericEmailHeader?: boolean
    aboutContent?: boolean
    aboutImageUrl?: boolean
    landingPageDesc?: boolean
    landingPageHeading?: boolean
    landingPageHero?: boolean
    landingPageSectionDesc?: boolean
    landingPageSectionHeading?: boolean
    landingPageSectionHero?: boolean
    conditionsSale?: boolean
    conditionsUse?: boolean
    privacyPolicy?: boolean
  }, ExtArgs["result"]["admin_editing"]>

  export type admin_editingSelectScalar = {
    id?: boolean
    updatedAt?: boolean
    genericEmailBody?: boolean
    genericEmailHeader?: boolean
    aboutContent?: boolean
    aboutImageUrl?: boolean
    landingPageDesc?: boolean
    landingPageHeading?: boolean
    landingPageHero?: boolean
    landingPageSectionDesc?: boolean
    landingPageSectionHeading?: boolean
    landingPageSectionHero?: boolean
    conditionsSale?: boolean
    conditionsUse?: boolean
    privacyPolicy?: boolean
  }


  export type $admin_editingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_editing"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      updatedAt: Date
      genericEmailBody: string | null
      genericEmailHeader: string | null
      aboutContent: string | null
      aboutImageUrl: string | null
      landingPageDesc: string | null
      landingPageHeading: string | null
      landingPageHero: string | null
      landingPageSectionDesc: string | null
      landingPageSectionHeading: string | null
      landingPageSectionHero: string | null
      conditionsSale: string | null
      conditionsUse: string | null
      privacyPolicy: string | null
    }, ExtArgs["result"]["admin_editing"]>
    composites: {}
  }

  type admin_editingGetPayload<S extends boolean | null | undefined | admin_editingDefaultArgs> = $Result.GetResult<Prisma.$admin_editingPayload, S>

  type admin_editingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_editingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_editingCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_editing 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 {admin_editingFindFirstArgs} args - Arguments to find a Admin_editing
     * @example
     * // Get one Admin_editing
     * const admin_editing = await prisma.admin_editing.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_editingFindFirstArgs>(args?: SelectSubset<T, admin_editingFindFirstArgs<ExtArgs>>): Prisma__admin_editingClient<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_editing 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 {admin_editingFindFirstOrThrowArgs} args - Arguments to find a Admin_editing
     * @example
     * // Get one Admin_editing
     * const admin_editing = await prisma.admin_editing.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_editingFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_editingFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_editingClient<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_editings 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 {admin_editingFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_editings
     * const admin_editings = await prisma.admin_editing.findMany()
     * 
     * // Get first 10 Admin_editings
     * const admin_editings = await prisma.admin_editing.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_editingWithIdOnly = await prisma.admin_editing.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_editingFindManyArgs>(args?: SelectSubset<T, admin_editingFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_editing.
     * @param {admin_editingCreateArgs} args - Arguments to create a Admin_editing.
     * @example
     * // Create one Admin_editing
     * const Admin_editing = await prisma.admin_editing.create({
     *   data: {
     *     // ... data to create a Admin_editing
     *   }
     * })
     * 
     */
    create<T extends admin_editingCreateArgs>(args: SelectSubset<T, admin_editingCreateArgs<ExtArgs>>): Prisma__admin_editingClient<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_editings and returns the data saved in the database.
     * @param {admin_editingCreateManyAndReturnArgs} args - Arguments to create many Admin_editings.
     * @example
     * // Create many Admin_editings
     * const admin_editing = await prisma.admin_editing.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_editings and only return the `id`
     * const admin_editingWithIdOnly = await prisma.admin_editing.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_editingCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_editingCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_editing.
     * @param {admin_editingDeleteArgs} args - Arguments to delete one Admin_editing.
     * @example
     * // Delete one Admin_editing
     * const Admin_editing = await prisma.admin_editing.delete({
     *   where: {
     *     // ... filter to delete one Admin_editing
     *   }
     * })
     * 
     */
    delete<T extends admin_editingDeleteArgs>(args: SelectSubset<T, admin_editingDeleteArgs<ExtArgs>>): Prisma__admin_editingClient<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_editing.
     * @param {admin_editingUpdateArgs} args - Arguments to update one Admin_editing.
     * @example
     * // Update one Admin_editing
     * const admin_editing = await prisma.admin_editing.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_editingUpdateArgs>(args: SelectSubset<T, admin_editingUpdateArgs<ExtArgs>>): Prisma__admin_editingClient<$Result.GetResult<Prisma.$admin_editingPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_editing.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_editingGroupByArgs} 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 admin_editingGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_editingGroupByArgs['orderBy'] }
        : { orderBy?: admin_editingGroupByArgs['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, admin_editingGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_editingGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_editing model
   */
  readonly fields: admin_editingFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_editing.
   * 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__admin_editingClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_editing model
   */ 
  interface admin_editingFieldRefs {
    readonly id: FieldRef<"admin_editing", 'Int'>
    readonly updatedAt: FieldRef<"admin_editing", 'DateTime'>
    readonly genericEmailBody: FieldRef<"admin_editing", 'String'>
    readonly genericEmailHeader: FieldRef<"admin_editing", 'String'>
    readonly aboutContent: FieldRef<"admin_editing", 'String'>
    readonly aboutImageUrl: FieldRef<"admin_editing", 'String'>
    readonly landingPageDesc: FieldRef<"admin_editing", 'String'>
    readonly landingPageHeading: FieldRef<"admin_editing", 'String'>
    readonly landingPageHero: FieldRef<"admin_editing", 'String'>
    readonly landingPageSectionDesc: FieldRef<"admin_editing", 'String'>
    readonly landingPageSectionHeading: FieldRef<"admin_editing", 'String'>
    readonly landingPageSectionHero: FieldRef<"admin_editing", 'String'>
    readonly conditionsSale: FieldRef<"admin_editing", 'String'>
    readonly conditionsUse: FieldRef<"admin_editing", 'String'>
    readonly privacyPolicy: FieldRef<"admin_editing", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_editing findUnique
   */
  export type admin_editingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * Filter, which admin_editing to fetch.
     */
    where: admin_editingWhereUniqueInput
  }

  /**
   * admin_editing findUniqueOrThrow
   */
  export type admin_editingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * Filter, which admin_editing to fetch.
     */
    where: admin_editingWhereUniqueInput
  }

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

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

  /**
   * admin_editing findMany
   */
  export type admin_editingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * Filter, which admin_editings to fetch.
     */
    where?: admin_editingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_editings to fetch.
     */
    orderBy?: admin_editingOrderByWithRelationInput | admin_editingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_editings.
     */
    cursor?: admin_editingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_editings 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` admin_editings.
     */
    skip?: number
    distinct?: Admin_editingScalarFieldEnum | Admin_editingScalarFieldEnum[]
  }

  /**
   * admin_editing create
   */
  export type admin_editingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_editing.
     */
    data: XOR<admin_editingCreateInput, admin_editingUncheckedCreateInput>
  }

  /**
   * admin_editing createMany
   */
  export type admin_editingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_editings.
     */
    data: admin_editingCreateManyInput | admin_editingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_editing createManyAndReturn
   */
  export type admin_editingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_editings.
     */
    data: admin_editingCreateManyInput | admin_editingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_editing update
   */
  export type admin_editingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_editing.
     */
    data: XOR<admin_editingUpdateInput, admin_editingUncheckedUpdateInput>
    /**
     * Choose, which admin_editing to update.
     */
    where: admin_editingWhereUniqueInput
  }

  /**
   * admin_editing updateMany
   */
  export type admin_editingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_editings.
     */
    data: XOR<admin_editingUpdateManyMutationInput, admin_editingUncheckedUpdateManyInput>
    /**
     * Filter which admin_editings to update
     */
    where?: admin_editingWhereInput
  }

  /**
   * admin_editing upsert
   */
  export type admin_editingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_editing to update in case it exists.
     */
    where: admin_editingWhereUniqueInput
    /**
     * In case the admin_editing found by the `where` argument doesn't exist, create a new admin_editing with this data.
     */
    create: XOR<admin_editingCreateInput, admin_editingUncheckedCreateInput>
    /**
     * In case the admin_editing was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_editingUpdateInput, admin_editingUncheckedUpdateInput>
  }

  /**
   * admin_editing delete
   */
  export type admin_editingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
    /**
     * Filter which admin_editing to delete.
     */
    where: admin_editingWhereUniqueInput
  }

  /**
   * admin_editing deleteMany
   */
  export type admin_editingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_editings to delete
     */
    where?: admin_editingWhereInput
  }

  /**
   * admin_editing without action
   */
  export type admin_editingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_editing
     */
    select?: admin_editingSelect<ExtArgs> | null
  }


  /**
   * Model admin_notification
   */

  export type AggregateAdmin_notification = {
    _count: Admin_notificationCountAggregateOutputType | null
    _avg: Admin_notificationAvgAggregateOutputType | null
    _sum: Admin_notificationSumAggregateOutputType | null
    _min: Admin_notificationMinAggregateOutputType | null
    _max: Admin_notificationMaxAggregateOutputType | null
  }

  export type Admin_notificationAvgAggregateOutputType = {
    id: number | null
  }

  export type Admin_notificationSumAggregateOutputType = {
    id: number | null
  }

  export type Admin_notificationMinAggregateOutputType = {
    id: number | null
    created_at: Date | null
    title: string | null
    link: string | null
    description: string | null
  }

  export type Admin_notificationMaxAggregateOutputType = {
    id: number | null
    created_at: Date | null
    title: string | null
    link: string | null
    description: string | null
  }

  export type Admin_notificationCountAggregateOutputType = {
    id: number
    created_at: number
    title: number
    link: number
    description: number
    _all: number
  }


  export type Admin_notificationAvgAggregateInputType = {
    id?: true
  }

  export type Admin_notificationSumAggregateInputType = {
    id?: true
  }

  export type Admin_notificationMinAggregateInputType = {
    id?: true
    created_at?: true
    title?: true
    link?: true
    description?: true
  }

  export type Admin_notificationMaxAggregateInputType = {
    id?: true
    created_at?: true
    title?: true
    link?: true
    description?: true
  }

  export type Admin_notificationCountAggregateInputType = {
    id?: true
    created_at?: true
    title?: true
    link?: true
    description?: true
    _all?: true
  }

  export type Admin_notificationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_notification to aggregate.
     */
    where?: admin_notificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notifications to fetch.
     */
    orderBy?: admin_notificationOrderByWithRelationInput | admin_notificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_notificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_notifications
    **/
    _count?: true | Admin_notificationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_notificationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_notificationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_notificationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_notificationMaxAggregateInputType
  }

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




  export type admin_notificationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_notificationWhereInput
    orderBy?: admin_notificationOrderByWithAggregationInput | admin_notificationOrderByWithAggregationInput[]
    by: Admin_notificationScalarFieldEnum[] | Admin_notificationScalarFieldEnum
    having?: admin_notificationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_notificationCountAggregateInputType | true
    _avg?: Admin_notificationAvgAggregateInputType
    _sum?: Admin_notificationSumAggregateInputType
    _min?: Admin_notificationMinAggregateInputType
    _max?: Admin_notificationMaxAggregateInputType
  }

  export type Admin_notificationGroupByOutputType = {
    id: number
    created_at: Date
    title: string
    link: string | null
    description: string
    _count: Admin_notificationCountAggregateOutputType | null
    _avg: Admin_notificationAvgAggregateOutputType | null
    _sum: Admin_notificationSumAggregateOutputType | null
    _min: Admin_notificationMinAggregateOutputType | null
    _max: Admin_notificationMaxAggregateOutputType | null
  }

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


  export type admin_notificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    title?: boolean
    link?: boolean
    description?: boolean
  }, ExtArgs["result"]["admin_notification"]>

  export type admin_notificationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    created_at?: boolean
    title?: boolean
    link?: boolean
    description?: boolean
  }, ExtArgs["result"]["admin_notification"]>

  export type admin_notificationSelectScalar = {
    id?: boolean
    created_at?: boolean
    title?: boolean
    link?: boolean
    description?: boolean
  }


  export type $admin_notificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_notification"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      created_at: Date
      title: string
      link: string | null
      description: string
    }, ExtArgs["result"]["admin_notification"]>
    composites: {}
  }

  type admin_notificationGetPayload<S extends boolean | null | undefined | admin_notificationDefaultArgs> = $Result.GetResult<Prisma.$admin_notificationPayload, S>

  type admin_notificationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_notificationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_notificationCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_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 {admin_notificationFindFirstArgs} args - Arguments to find a Admin_notification
     * @example
     * // Get one Admin_notification
     * const admin_notification = await prisma.admin_notification.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_notificationFindFirstArgs>(args?: SelectSubset<T, admin_notificationFindFirstArgs<ExtArgs>>): Prisma__admin_notificationClient<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_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 {admin_notificationFindFirstOrThrowArgs} args - Arguments to find a Admin_notification
     * @example
     * // Get one Admin_notification
     * const admin_notification = await prisma.admin_notification.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_notificationFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_notificationFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_notificationClient<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_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 {admin_notificationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_notifications
     * const admin_notifications = await prisma.admin_notification.findMany()
     * 
     * // Get first 10 Admin_notifications
     * const admin_notifications = await prisma.admin_notification.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_notificationWithIdOnly = await prisma.admin_notification.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_notificationFindManyArgs>(args?: SelectSubset<T, admin_notificationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_notification.
     * @param {admin_notificationCreateArgs} args - Arguments to create a Admin_notification.
     * @example
     * // Create one Admin_notification
     * const Admin_notification = await prisma.admin_notification.create({
     *   data: {
     *     // ... data to create a Admin_notification
     *   }
     * })
     * 
     */
    create<T extends admin_notificationCreateArgs>(args: SelectSubset<T, admin_notificationCreateArgs<ExtArgs>>): Prisma__admin_notificationClient<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_notifications and returns the data saved in the database.
     * @param {admin_notificationCreateManyAndReturnArgs} args - Arguments to create many Admin_notifications.
     * @example
     * // Create many Admin_notifications
     * const admin_notification = await prisma.admin_notification.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_notifications and only return the `id`
     * const admin_notificationWithIdOnly = await prisma.admin_notification.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_notificationCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_notificationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_notification.
     * @param {admin_notificationDeleteArgs} args - Arguments to delete one Admin_notification.
     * @example
     * // Delete one Admin_notification
     * const Admin_notification = await prisma.admin_notification.delete({
     *   where: {
     *     // ... filter to delete one Admin_notification
     *   }
     * })
     * 
     */
    delete<T extends admin_notificationDeleteArgs>(args: SelectSubset<T, admin_notificationDeleteArgs<ExtArgs>>): Prisma__admin_notificationClient<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_notification.
     * @param {admin_notificationUpdateArgs} args - Arguments to update one Admin_notification.
     * @example
     * // Update one Admin_notification
     * const admin_notification = await prisma.admin_notification.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_notificationUpdateArgs>(args: SelectSubset<T, admin_notificationUpdateArgs<ExtArgs>>): Prisma__admin_notificationClient<$Result.GetResult<Prisma.$admin_notificationPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_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 admin_notificationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_notificationGroupByArgs['orderBy'] }
        : { orderBy?: admin_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, admin_notificationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_notificationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_notification model
   */
  readonly fields: admin_notificationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_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__admin_notificationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_notification model
   */ 
  interface admin_notificationFieldRefs {
    readonly id: FieldRef<"admin_notification", 'Int'>
    readonly created_at: FieldRef<"admin_notification", 'DateTime'>
    readonly title: FieldRef<"admin_notification", 'String'>
    readonly link: FieldRef<"admin_notification", 'String'>
    readonly description: FieldRef<"admin_notification", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_notification findUnique
   */
  export type admin_notificationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification to fetch.
     */
    where: admin_notificationWhereUniqueInput
  }

  /**
   * admin_notification findUniqueOrThrow
   */
  export type admin_notificationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification to fetch.
     */
    where: admin_notificationWhereUniqueInput
  }

  /**
   * admin_notification findFirst
   */
  export type admin_notificationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification to fetch.
     */
    where?: admin_notificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notifications to fetch.
     */
    orderBy?: admin_notificationOrderByWithRelationInput | admin_notificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_notifications.
     */
    cursor?: admin_notificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_notifications.
     */
    distinct?: Admin_notificationScalarFieldEnum | Admin_notificationScalarFieldEnum[]
  }

  /**
   * admin_notification findFirstOrThrow
   */
  export type admin_notificationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification to fetch.
     */
    where?: admin_notificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notifications to fetch.
     */
    orderBy?: admin_notificationOrderByWithRelationInput | admin_notificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_notifications.
     */
    cursor?: admin_notificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_notifications.
     */
    distinct?: Admin_notificationScalarFieldEnum | Admin_notificationScalarFieldEnum[]
  }

  /**
   * admin_notification findMany
   */
  export type admin_notificationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter, which admin_notifications to fetch.
     */
    where?: admin_notificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notifications to fetch.
     */
    orderBy?: admin_notificationOrderByWithRelationInput | admin_notificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_notifications.
     */
    cursor?: admin_notificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_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` admin_notifications.
     */
    skip?: number
    distinct?: Admin_notificationScalarFieldEnum | Admin_notificationScalarFieldEnum[]
  }

  /**
   * admin_notification create
   */
  export type admin_notificationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_notification.
     */
    data: XOR<admin_notificationCreateInput, admin_notificationUncheckedCreateInput>
  }

  /**
   * admin_notification createMany
   */
  export type admin_notificationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_notifications.
     */
    data: admin_notificationCreateManyInput | admin_notificationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_notification createManyAndReturn
   */
  export type admin_notificationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_notifications.
     */
    data: admin_notificationCreateManyInput | admin_notificationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_notification update
   */
  export type admin_notificationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_notification.
     */
    data: XOR<admin_notificationUpdateInput, admin_notificationUncheckedUpdateInput>
    /**
     * Choose, which admin_notification to update.
     */
    where: admin_notificationWhereUniqueInput
  }

  /**
   * admin_notification updateMany
   */
  export type admin_notificationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_notifications.
     */
    data: XOR<admin_notificationUpdateManyMutationInput, admin_notificationUncheckedUpdateManyInput>
    /**
     * Filter which admin_notifications to update
     */
    where?: admin_notificationWhereInput
  }

  /**
   * admin_notification upsert
   */
  export type admin_notificationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_notification to update in case it exists.
     */
    where: admin_notificationWhereUniqueInput
    /**
     * In case the admin_notification found by the `where` argument doesn't exist, create a new admin_notification with this data.
     */
    create: XOR<admin_notificationCreateInput, admin_notificationUncheckedCreateInput>
    /**
     * In case the admin_notification was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_notificationUpdateInput, admin_notificationUncheckedUpdateInput>
  }

  /**
   * admin_notification delete
   */
  export type admin_notificationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
    /**
     * Filter which admin_notification to delete.
     */
    where: admin_notificationWhereUniqueInput
  }

  /**
   * admin_notification deleteMany
   */
  export type admin_notificationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_notifications to delete
     */
    where?: admin_notificationWhereInput
  }

  /**
   * admin_notification without action
   */
  export type admin_notificationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification
     */
    select?: admin_notificationSelect<ExtArgs> | null
  }


  /**
   * Model admin_notification_status
   */

  export type AggregateAdmin_notification_status = {
    _count: Admin_notification_statusCountAggregateOutputType | null
    _avg: Admin_notification_statusAvgAggregateOutputType | null
    _sum: Admin_notification_statusSumAggregateOutputType | null
    _min: Admin_notification_statusMinAggregateOutputType | null
    _max: Admin_notification_statusMaxAggregateOutputType | null
  }

  export type Admin_notification_statusAvgAggregateOutputType = {
    id: number | null
  }

  export type Admin_notification_statusSumAggregateOutputType = {
    id: number | null
  }

  export type Admin_notification_statusMinAggregateOutputType = {
    id: number | null
    status: $Enums.NotificationStatus | null
    newExpertApplication: $Enums.NotificationStatus | null
    newInvitationAccepted: $Enums.NotificationStatus | null
    newIdVerification: $Enums.NotificationStatus | null
  }

  export type Admin_notification_statusMaxAggregateOutputType = {
    id: number | null
    status: $Enums.NotificationStatus | null
    newExpertApplication: $Enums.NotificationStatus | null
    newInvitationAccepted: $Enums.NotificationStatus | null
    newIdVerification: $Enums.NotificationStatus | null
  }

  export type Admin_notification_statusCountAggregateOutputType = {
    id: number
    status: number
    newExpertApplication: number
    newInvitationAccepted: number
    newIdVerification: number
    _all: number
  }


  export type Admin_notification_statusAvgAggregateInputType = {
    id?: true
  }

  export type Admin_notification_statusSumAggregateInputType = {
    id?: true
  }

  export type Admin_notification_statusMinAggregateInputType = {
    id?: true
    status?: true
    newExpertApplication?: true
    newInvitationAccepted?: true
    newIdVerification?: true
  }

  export type Admin_notification_statusMaxAggregateInputType = {
    id?: true
    status?: true
    newExpertApplication?: true
    newInvitationAccepted?: true
    newIdVerification?: true
  }

  export type Admin_notification_statusCountAggregateInputType = {
    id?: true
    status?: true
    newExpertApplication?: true
    newInvitationAccepted?: true
    newIdVerification?: true
    _all?: true
  }

  export type Admin_notification_statusAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_notification_status to aggregate.
     */
    where?: admin_notification_statusWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notification_statuses to fetch.
     */
    orderBy?: admin_notification_statusOrderByWithRelationInput | admin_notification_statusOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_notification_statusWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_notification_statuses 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` admin_notification_statuses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_notification_statuses
    **/
    _count?: true | Admin_notification_statusCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Admin_notification_statusAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Admin_notification_statusSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_notification_statusMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_notification_statusMaxAggregateInputType
  }

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




  export type admin_notification_statusGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_notification_statusWhereInput
    orderBy?: admin_notification_statusOrderByWithAggregationInput | admin_notification_statusOrderByWithAggregationInput[]
    by: Admin_notification_statusScalarFieldEnum[] | Admin_notification_statusScalarFieldEnum
    having?: admin_notification_statusScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_notification_statusCountAggregateInputType | true
    _avg?: Admin_notification_statusAvgAggregateInputType
    _sum?: Admin_notification_statusSumAggregateInputType
    _min?: Admin_notification_statusMinAggregateInputType
    _max?: Admin_notification_statusMaxAggregateInputType
  }

  export type Admin_notification_statusGroupByOutputType = {
    id: number
    status: $Enums.NotificationStatus
    newExpertApplication: $Enums.NotificationStatus
    newInvitationAccepted: $Enums.NotificationStatus
    newIdVerification: $Enums.NotificationStatus
    _count: Admin_notification_statusCountAggregateOutputType | null
    _avg: Admin_notification_statusAvgAggregateOutputType | null
    _sum: Admin_notification_statusSumAggregateOutputType | null
    _min: Admin_notification_statusMinAggregateOutputType | null
    _max: Admin_notification_statusMaxAggregateOutputType | null
  }

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


  export type admin_notification_statusSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    newExpertApplication?: boolean
    newInvitationAccepted?: boolean
    newIdVerification?: boolean
  }, ExtArgs["result"]["admin_notification_status"]>

  export type admin_notification_statusSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    newExpertApplication?: boolean
    newInvitationAccepted?: boolean
    newIdVerification?: boolean
  }, ExtArgs["result"]["admin_notification_status"]>

  export type admin_notification_statusSelectScalar = {
    id?: boolean
    status?: boolean
    newExpertApplication?: boolean
    newInvitationAccepted?: boolean
    newIdVerification?: boolean
  }


  export type $admin_notification_statusPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_notification_status"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      status: $Enums.NotificationStatus
      newExpertApplication: $Enums.NotificationStatus
      newInvitationAccepted: $Enums.NotificationStatus
      newIdVerification: $Enums.NotificationStatus
    }, ExtArgs["result"]["admin_notification_status"]>
    composites: {}
  }

  type admin_notification_statusGetPayload<S extends boolean | null | undefined | admin_notification_statusDefaultArgs> = $Result.GetResult<Prisma.$admin_notification_statusPayload, S>

  type admin_notification_statusCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_notification_statusFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_notification_statusCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Admin_notification_status 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 {admin_notification_statusFindFirstArgs} args - Arguments to find a Admin_notification_status
     * @example
     * // Get one Admin_notification_status
     * const admin_notification_status = await prisma.admin_notification_status.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends admin_notification_statusFindFirstArgs>(args?: SelectSubset<T, admin_notification_statusFindFirstArgs<ExtArgs>>): Prisma__admin_notification_statusClient<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Admin_notification_status 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 {admin_notification_statusFindFirstOrThrowArgs} args - Arguments to find a Admin_notification_status
     * @example
     * // Get one Admin_notification_status
     * const admin_notification_status = await prisma.admin_notification_status.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends admin_notification_statusFindFirstOrThrowArgs>(args?: SelectSubset<T, admin_notification_statusFindFirstOrThrowArgs<ExtArgs>>): Prisma__admin_notification_statusClient<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Admin_notification_statuses 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 {admin_notification_statusFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Admin_notification_statuses
     * const admin_notification_statuses = await prisma.admin_notification_status.findMany()
     * 
     * // Get first 10 Admin_notification_statuses
     * const admin_notification_statuses = await prisma.admin_notification_status.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const admin_notification_statusWithIdOnly = await prisma.admin_notification_status.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends admin_notification_statusFindManyArgs>(args?: SelectSubset<T, admin_notification_statusFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Admin_notification_status.
     * @param {admin_notification_statusCreateArgs} args - Arguments to create a Admin_notification_status.
     * @example
     * // Create one Admin_notification_status
     * const Admin_notification_status = await prisma.admin_notification_status.create({
     *   data: {
     *     // ... data to create a Admin_notification_status
     *   }
     * })
     * 
     */
    create<T extends admin_notification_statusCreateArgs>(args: SelectSubset<T, admin_notification_statusCreateArgs<ExtArgs>>): Prisma__admin_notification_statusClient<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_notification_statuses and returns the data saved in the database.
     * @param {admin_notification_statusCreateManyAndReturnArgs} args - Arguments to create many Admin_notification_statuses.
     * @example
     * // Create many Admin_notification_statuses
     * const admin_notification_status = await prisma.admin_notification_status.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_notification_statuses and only return the `id`
     * const admin_notification_statusWithIdOnly = await prisma.admin_notification_status.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_notification_statusCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_notification_statusCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_notification_status.
     * @param {admin_notification_statusDeleteArgs} args - Arguments to delete one Admin_notification_status.
     * @example
     * // Delete one Admin_notification_status
     * const Admin_notification_status = await prisma.admin_notification_status.delete({
     *   where: {
     *     // ... filter to delete one Admin_notification_status
     *   }
     * })
     * 
     */
    delete<T extends admin_notification_statusDeleteArgs>(args: SelectSubset<T, admin_notification_statusDeleteArgs<ExtArgs>>): Prisma__admin_notification_statusClient<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_notification_status.
     * @param {admin_notification_statusUpdateArgs} args - Arguments to update one Admin_notification_status.
     * @example
     * // Update one Admin_notification_status
     * const admin_notification_status = await prisma.admin_notification_status.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_notification_statusUpdateArgs>(args: SelectSubset<T, admin_notification_statusUpdateArgs<ExtArgs>>): Prisma__admin_notification_statusClient<$Result.GetResult<Prisma.$admin_notification_statusPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by Admin_notification_status.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_notification_statusGroupByArgs} 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 admin_notification_statusGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_notification_statusGroupByArgs['orderBy'] }
        : { orderBy?: admin_notification_statusGroupByArgs['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, admin_notification_statusGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_notification_statusGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_notification_status model
   */
  readonly fields: admin_notification_statusFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_notification_status.
   * 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__admin_notification_statusClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 admin_notification_status model
   */ 
  interface admin_notification_statusFieldRefs {
    readonly id: FieldRef<"admin_notification_status", 'Int'>
    readonly status: FieldRef<"admin_notification_status", 'NotificationStatus'>
    readonly newExpertApplication: FieldRef<"admin_notification_status", 'NotificationStatus'>
    readonly newInvitationAccepted: FieldRef<"admin_notification_status", 'NotificationStatus'>
    readonly newIdVerification: FieldRef<"admin_notification_status", 'NotificationStatus'>
  }
    

  // Custom InputTypes
  /**
   * admin_notification_status findUnique
   */
  export type admin_notification_statusFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification_status to fetch.
     */
    where: admin_notification_statusWhereUniqueInput
  }

  /**
   * admin_notification_status findUniqueOrThrow
   */
  export type admin_notification_statusFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification_status to fetch.
     */
    where: admin_notification_statusWhereUniqueInput
  }

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

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

  /**
   * admin_notification_status findMany
   */
  export type admin_notification_statusFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * Filter, which admin_notification_statuses to fetch.
     */
    where?: admin_notification_statusWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_notification_statuses to fetch.
     */
    orderBy?: admin_notification_statusOrderByWithRelationInput | admin_notification_statusOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_notification_statuses.
     */
    cursor?: admin_notification_statusWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_notification_statuses 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` admin_notification_statuses.
     */
    skip?: number
    distinct?: Admin_notification_statusScalarFieldEnum | Admin_notification_statusScalarFieldEnum[]
  }

  /**
   * admin_notification_status create
   */
  export type admin_notification_statusCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * The data needed to create a admin_notification_status.
     */
    data?: XOR<admin_notification_statusCreateInput, admin_notification_statusUncheckedCreateInput>
  }

  /**
   * admin_notification_status createMany
   */
  export type admin_notification_statusCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_notification_statuses.
     */
    data: admin_notification_statusCreateManyInput | admin_notification_statusCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_notification_status createManyAndReturn
   */
  export type admin_notification_statusCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_notification_statuses.
     */
    data: admin_notification_statusCreateManyInput | admin_notification_statusCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_notification_status update
   */
  export type admin_notification_statusUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * The data needed to update a admin_notification_status.
     */
    data: XOR<admin_notification_statusUpdateInput, admin_notification_statusUncheckedUpdateInput>
    /**
     * Choose, which admin_notification_status to update.
     */
    where: admin_notification_statusWhereUniqueInput
  }

  /**
   * admin_notification_status updateMany
   */
  export type admin_notification_statusUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_notification_statuses.
     */
    data: XOR<admin_notification_statusUpdateManyMutationInput, admin_notification_statusUncheckedUpdateManyInput>
    /**
     * Filter which admin_notification_statuses to update
     */
    where?: admin_notification_statusWhereInput
  }

  /**
   * admin_notification_status upsert
   */
  export type admin_notification_statusUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * The filter to search for the admin_notification_status to update in case it exists.
     */
    where: admin_notification_statusWhereUniqueInput
    /**
     * In case the admin_notification_status found by the `where` argument doesn't exist, create a new admin_notification_status with this data.
     */
    create: XOR<admin_notification_statusCreateInput, admin_notification_statusUncheckedCreateInput>
    /**
     * In case the admin_notification_status was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_notification_statusUpdateInput, admin_notification_statusUncheckedUpdateInput>
  }

  /**
   * admin_notification_status delete
   */
  export type admin_notification_statusDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
    /**
     * Filter which admin_notification_status to delete.
     */
    where: admin_notification_statusWhereUniqueInput
  }

  /**
   * admin_notification_status deleteMany
   */
  export type admin_notification_statusDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_notification_statuses to delete
     */
    where?: admin_notification_statusWhereInput
  }

  /**
   * admin_notification_status without action
   */
  export type admin_notification_statusDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_notification_status
     */
    select?: admin_notification_statusSelect<ExtArgs> | null
  }


  /**
   * Model expertApplicationAnswer
   */

  export type AggregateExpertApplicationAnswer = {
    _count: ExpertApplicationAnswerCountAggregateOutputType | null
    _min: ExpertApplicationAnswerMinAggregateOutputType | null
    _max: ExpertApplicationAnswerMaxAggregateOutputType | null
  }

  export type ExpertApplicationAnswerMinAggregateOutputType = {
    id: string | null
    answer: string | null
    created_at: Date | null
    userId: string | null
    questionId: string | null
    admin_expert_applicationId: string | null
  }

  export type ExpertApplicationAnswerMaxAggregateOutputType = {
    id: string | null
    answer: string | null
    created_at: Date | null
    userId: string | null
    questionId: string | null
    admin_expert_applicationId: string | null
  }

  export type ExpertApplicationAnswerCountAggregateOutputType = {
    id: number
    answer: number
    created_at: number
    userId: number
    questionId: number
    admin_expert_applicationId: number
    _all: number
  }


  export type ExpertApplicationAnswerMinAggregateInputType = {
    id?: true
    answer?: true
    created_at?: true
    userId?: true
    questionId?: true
    admin_expert_applicationId?: true
  }

  export type ExpertApplicationAnswerMaxAggregateInputType = {
    id?: true
    answer?: true
    created_at?: true
    userId?: true
    questionId?: true
    admin_expert_applicationId?: true
  }

  export type ExpertApplicationAnswerCountAggregateInputType = {
    id?: true
    answer?: true
    created_at?: true
    userId?: true
    questionId?: true
    admin_expert_applicationId?: true
    _all?: true
  }

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

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




  export type expertApplicationAnswerGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: expertApplicationAnswerWhereInput
    orderBy?: expertApplicationAnswerOrderByWithAggregationInput | expertApplicationAnswerOrderByWithAggregationInput[]
    by: ExpertApplicationAnswerScalarFieldEnum[] | ExpertApplicationAnswerScalarFieldEnum
    having?: expertApplicationAnswerScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertApplicationAnswerCountAggregateInputType | true
    _min?: ExpertApplicationAnswerMinAggregateInputType
    _max?: ExpertApplicationAnswerMaxAggregateInputType
  }

  export type ExpertApplicationAnswerGroupByOutputType = {
    id: string
    answer: string
    created_at: Date
    userId: string
    questionId: string
    admin_expert_applicationId: string | null
    _count: ExpertApplicationAnswerCountAggregateOutputType | null
    _min: ExpertApplicationAnswerMinAggregateOutputType | null
    _max: ExpertApplicationAnswerMaxAggregateOutputType | null
  }

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


  export type expertApplicationAnswerSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    answer?: boolean
    created_at?: boolean
    userId?: boolean
    questionId?: boolean
    admin_expert_applicationId?: boolean
    admin_expert_application?: boolean | expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs>
    expertApplicationQuestion?: boolean | expertApplicationQuestionDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertApplicationAnswer"]>

  export type expertApplicationAnswerSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    answer?: boolean
    created_at?: boolean
    userId?: boolean
    questionId?: boolean
    admin_expert_applicationId?: boolean
    admin_expert_application?: boolean | expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs>
    expertApplicationQuestion?: boolean | expertApplicationQuestionDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertApplicationAnswer"]>

  export type expertApplicationAnswerSelectScalar = {
    id?: boolean
    answer?: boolean
    created_at?: boolean
    userId?: boolean
    questionId?: boolean
    admin_expert_applicationId?: boolean
  }

  export type expertApplicationAnswerInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    admin_expert_application?: boolean | expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs>
    expertApplicationQuestion?: boolean | expertApplicationQuestionDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type expertApplicationAnswerIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    admin_expert_application?: boolean | expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs>
    expertApplicationQuestion?: boolean | expertApplicationQuestionDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $expertApplicationAnswerPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "expertApplicationAnswer"
    objects: {
      admin_expert_application: Prisma.$admin_expert_applicationPayload<ExtArgs> | null
      expertApplicationQuestion: Prisma.$expertApplicationQuestionPayload<ExtArgs>
      User: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      answer: string
      created_at: Date
      userId: string
      questionId: string
      admin_expert_applicationId: string | null
    }, ExtArgs["result"]["expertApplicationAnswer"]>
    composites: {}
  }

  type expertApplicationAnswerGetPayload<S extends boolean | null | undefined | expertApplicationAnswerDefaultArgs> = $Result.GetResult<Prisma.$expertApplicationAnswerPayload, S>

  type expertApplicationAnswerCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<expertApplicationAnswerFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExpertApplicationAnswerCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ExpertApplicationAnswer 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 {expertApplicationAnswerFindFirstArgs} args - Arguments to find a ExpertApplicationAnswer
     * @example
     * // Get one ExpertApplicationAnswer
     * const expertApplicationAnswer = await prisma.expertApplicationAnswer.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends expertApplicationAnswerFindFirstArgs>(args?: SelectSubset<T, expertApplicationAnswerFindFirstArgs<ExtArgs>>): Prisma__expertApplicationAnswerClient<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ExpertApplicationAnswer 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 {expertApplicationAnswerFindFirstOrThrowArgs} args - Arguments to find a ExpertApplicationAnswer
     * @example
     * // Get one ExpertApplicationAnswer
     * const expertApplicationAnswer = await prisma.expertApplicationAnswer.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends expertApplicationAnswerFindFirstOrThrowArgs>(args?: SelectSubset<T, expertApplicationAnswerFindFirstOrThrowArgs<ExtArgs>>): Prisma__expertApplicationAnswerClient<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ExpertApplicationAnswers 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 {expertApplicationAnswerFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ExpertApplicationAnswers
     * const expertApplicationAnswers = await prisma.expertApplicationAnswer.findMany()
     * 
     * // Get first 10 ExpertApplicationAnswers
     * const expertApplicationAnswers = await prisma.expertApplicationAnswer.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const expertApplicationAnswerWithIdOnly = await prisma.expertApplicationAnswer.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends expertApplicationAnswerFindManyArgs>(args?: SelectSubset<T, expertApplicationAnswerFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ExpertApplicationAnswer.
     * @param {expertApplicationAnswerCreateArgs} args - Arguments to create a ExpertApplicationAnswer.
     * @example
     * // Create one ExpertApplicationAnswer
     * const ExpertApplicationAnswer = await prisma.expertApplicationAnswer.create({
     *   data: {
     *     // ... data to create a ExpertApplicationAnswer
     *   }
     * })
     * 
     */
    create<T extends expertApplicationAnswerCreateArgs>(args: SelectSubset<T, expertApplicationAnswerCreateArgs<ExtArgs>>): Prisma__expertApplicationAnswerClient<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many ExpertApplicationAnswers and returns the data saved in the database.
     * @param {expertApplicationAnswerCreateManyAndReturnArgs} args - Arguments to create many ExpertApplicationAnswers.
     * @example
     * // Create many ExpertApplicationAnswers
     * const expertApplicationAnswer = await prisma.expertApplicationAnswer.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ExpertApplicationAnswers and only return the `id`
     * const expertApplicationAnswerWithIdOnly = await prisma.expertApplicationAnswer.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends expertApplicationAnswerCreateManyAndReturnArgs>(args?: SelectSubset<T, expertApplicationAnswerCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a ExpertApplicationAnswer.
     * @param {expertApplicationAnswerDeleteArgs} args - Arguments to delete one ExpertApplicationAnswer.
     * @example
     * // Delete one ExpertApplicationAnswer
     * const ExpertApplicationAnswer = await prisma.expertApplicationAnswer.delete({
     *   where: {
     *     // ... filter to delete one ExpertApplicationAnswer
     *   }
     * })
     * 
     */
    delete<T extends expertApplicationAnswerDeleteArgs>(args: SelectSubset<T, expertApplicationAnswerDeleteArgs<ExtArgs>>): Prisma__expertApplicationAnswerClient<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ExpertApplicationAnswer.
     * @param {expertApplicationAnswerUpdateArgs} args - Arguments to update one ExpertApplicationAnswer.
     * @example
     * // Update one ExpertApplicationAnswer
     * const expertApplicationAnswer = await prisma.expertApplicationAnswer.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends expertApplicationAnswerUpdateArgs>(args: SelectSubset<T, expertApplicationAnswerUpdateArgs<ExtArgs>>): Prisma__expertApplicationAnswerClient<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by ExpertApplicationAnswer.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {expertApplicationAnswerGroupByArgs} 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 expertApplicationAnswerGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: expertApplicationAnswerGroupByArgs['orderBy'] }
        : { orderBy?: expertApplicationAnswerGroupByArgs['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, expertApplicationAnswerGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExpertApplicationAnswerGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the expertApplicationAnswer model
   */
  readonly fields: expertApplicationAnswerFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for expertApplicationAnswer.
   * 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__expertApplicationAnswerClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    admin_expert_application<T extends expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs> = {}>(args?: Subset<T, expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs>>): Prisma__admin_expert_applicationClient<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    expertApplicationQuestion<T extends expertApplicationQuestionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, expertApplicationQuestionDefaultArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    User<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 expertApplicationAnswer model
   */ 
  interface expertApplicationAnswerFieldRefs {
    readonly id: FieldRef<"expertApplicationAnswer", 'String'>
    readonly answer: FieldRef<"expertApplicationAnswer", 'String'>
    readonly created_at: FieldRef<"expertApplicationAnswer", 'DateTime'>
    readonly userId: FieldRef<"expertApplicationAnswer", 'String'>
    readonly questionId: FieldRef<"expertApplicationAnswer", 'String'>
    readonly admin_expert_applicationId: FieldRef<"expertApplicationAnswer", 'String'>
  }
    

  // Custom InputTypes
  /**
   * expertApplicationAnswer findUnique
   */
  export type expertApplicationAnswerFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationAnswer to fetch.
     */
    where: expertApplicationAnswerWhereUniqueInput
  }

  /**
   * expertApplicationAnswer findUniqueOrThrow
   */
  export type expertApplicationAnswerFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationAnswer to fetch.
     */
    where: expertApplicationAnswerWhereUniqueInput
  }

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

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

  /**
   * expertApplicationAnswer findMany
   */
  export type expertApplicationAnswerFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationAnswers to fetch.
     */
    where?: expertApplicationAnswerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of expertApplicationAnswers to fetch.
     */
    orderBy?: expertApplicationAnswerOrderByWithRelationInput | expertApplicationAnswerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing expertApplicationAnswers.
     */
    cursor?: expertApplicationAnswerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` expertApplicationAnswers 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` expertApplicationAnswers.
     */
    skip?: number
    distinct?: ExpertApplicationAnswerScalarFieldEnum | ExpertApplicationAnswerScalarFieldEnum[]
  }

  /**
   * expertApplicationAnswer create
   */
  export type expertApplicationAnswerCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * The data needed to create a expertApplicationAnswer.
     */
    data: XOR<expertApplicationAnswerCreateInput, expertApplicationAnswerUncheckedCreateInput>
  }

  /**
   * expertApplicationAnswer createMany
   */
  export type expertApplicationAnswerCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many expertApplicationAnswers.
     */
    data: expertApplicationAnswerCreateManyInput | expertApplicationAnswerCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * expertApplicationAnswer createManyAndReturn
   */
  export type expertApplicationAnswerCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many expertApplicationAnswers.
     */
    data: expertApplicationAnswerCreateManyInput | expertApplicationAnswerCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * expertApplicationAnswer update
   */
  export type expertApplicationAnswerUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * The data needed to update a expertApplicationAnswer.
     */
    data: XOR<expertApplicationAnswerUpdateInput, expertApplicationAnswerUncheckedUpdateInput>
    /**
     * Choose, which expertApplicationAnswer to update.
     */
    where: expertApplicationAnswerWhereUniqueInput
  }

  /**
   * expertApplicationAnswer updateMany
   */
  export type expertApplicationAnswerUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update expertApplicationAnswers.
     */
    data: XOR<expertApplicationAnswerUpdateManyMutationInput, expertApplicationAnswerUncheckedUpdateManyInput>
    /**
     * Filter which expertApplicationAnswers to update
     */
    where?: expertApplicationAnswerWhereInput
  }

  /**
   * expertApplicationAnswer upsert
   */
  export type expertApplicationAnswerUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * The filter to search for the expertApplicationAnswer to update in case it exists.
     */
    where: expertApplicationAnswerWhereUniqueInput
    /**
     * In case the expertApplicationAnswer found by the `where` argument doesn't exist, create a new expertApplicationAnswer with this data.
     */
    create: XOR<expertApplicationAnswerCreateInput, expertApplicationAnswerUncheckedCreateInput>
    /**
     * In case the expertApplicationAnswer was found with the provided `where` argument, update it with this data.
     */
    update: XOR<expertApplicationAnswerUpdateInput, expertApplicationAnswerUncheckedUpdateInput>
  }

  /**
   * expertApplicationAnswer delete
   */
  export type expertApplicationAnswerDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    /**
     * Filter which expertApplicationAnswer to delete.
     */
    where: expertApplicationAnswerWhereUniqueInput
  }

  /**
   * expertApplicationAnswer deleteMany
   */
  export type expertApplicationAnswerDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which expertApplicationAnswers to delete
     */
    where?: expertApplicationAnswerWhereInput
  }

  /**
   * expertApplicationAnswer.admin_expert_application
   */
  export type expertApplicationAnswer$admin_expert_applicationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    where?: admin_expert_applicationWhereInput
  }

  /**
   * expertApplicationAnswer without action
   */
  export type expertApplicationAnswerDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
  }


  /**
   * Model admin_expert_application
   */

  export type AggregateAdmin_expert_application = {
    _count: Admin_expert_applicationCountAggregateOutputType | null
    _min: Admin_expert_applicationMinAggregateOutputType | null
    _max: Admin_expert_applicationMaxAggregateOutputType | null
  }

  export type Admin_expert_applicationMinAggregateOutputType = {
    id: string | null
    status: $Enums.Status | null
    createdAt: Date | null
    userId: string | null
  }

  export type Admin_expert_applicationMaxAggregateOutputType = {
    id: string | null
    status: $Enums.Status | null
    createdAt: Date | null
    userId: string | null
  }

  export type Admin_expert_applicationCountAggregateOutputType = {
    id: number
    status: number
    createdAt: number
    userId: number
    _all: number
  }


  export type Admin_expert_applicationMinAggregateInputType = {
    id?: true
    status?: true
    createdAt?: true
    userId?: true
  }

  export type Admin_expert_applicationMaxAggregateInputType = {
    id?: true
    status?: true
    createdAt?: true
    userId?: true
  }

  export type Admin_expert_applicationCountAggregateInputType = {
    id?: true
    status?: true
    createdAt?: true
    userId?: true
    _all?: true
  }

  export type Admin_expert_applicationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_expert_application to aggregate.
     */
    where?: admin_expert_applicationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_expert_applications to fetch.
     */
    orderBy?: admin_expert_applicationOrderByWithRelationInput | admin_expert_applicationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: admin_expert_applicationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_expert_applications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` admin_expert_applications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned admin_expert_applications
    **/
    _count?: true | Admin_expert_applicationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Admin_expert_applicationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Admin_expert_applicationMaxAggregateInputType
  }

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




  export type admin_expert_applicationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: admin_expert_applicationWhereInput
    orderBy?: admin_expert_applicationOrderByWithAggregationInput | admin_expert_applicationOrderByWithAggregationInput[]
    by: Admin_expert_applicationScalarFieldEnum[] | Admin_expert_applicationScalarFieldEnum
    having?: admin_expert_applicationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Admin_expert_applicationCountAggregateInputType | true
    _min?: Admin_expert_applicationMinAggregateInputType
    _max?: Admin_expert_applicationMaxAggregateInputType
  }

  export type Admin_expert_applicationGroupByOutputType = {
    id: string
    status: $Enums.Status
    createdAt: Date
    userId: string
    _count: Admin_expert_applicationCountAggregateOutputType | null
    _min: Admin_expert_applicationMinAggregateOutputType | null
    _max: Admin_expert_applicationMaxAggregateOutputType | null
  }

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


  export type admin_expert_applicationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    createdAt?: boolean
    userId?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
    answer?: boolean | admin_expert_application$answerArgs<ExtArgs>
    _count?: boolean | Admin_expert_applicationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["admin_expert_application"]>

  export type admin_expert_applicationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    status?: boolean
    createdAt?: boolean
    userId?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["admin_expert_application"]>

  export type admin_expert_applicationSelectScalar = {
    id?: boolean
    status?: boolean
    createdAt?: boolean
    userId?: boolean
  }

  export type admin_expert_applicationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
    answer?: boolean | admin_expert_application$answerArgs<ExtArgs>
    _count?: boolean | Admin_expert_applicationCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type admin_expert_applicationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $admin_expert_applicationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "admin_expert_application"
    objects: {
      User: Prisma.$UserPayload<ExtArgs>
      answer: Prisma.$expertApplicationAnswerPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      status: $Enums.Status
      createdAt: Date
      userId: string
    }, ExtArgs["result"]["admin_expert_application"]>
    composites: {}
  }

  type admin_expert_applicationGetPayload<S extends boolean | null | undefined | admin_expert_applicationDefaultArgs> = $Result.GetResult<Prisma.$admin_expert_applicationPayload, S>

  type admin_expert_applicationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<admin_expert_applicationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Admin_expert_applicationCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Admin_expert_application.
     * @param {admin_expert_applicationCreateArgs} args - Arguments to create a Admin_expert_application.
     * @example
     * // Create one Admin_expert_application
     * const Admin_expert_application = await prisma.admin_expert_application.create({
     *   data: {
     *     // ... data to create a Admin_expert_application
     *   }
     * })
     * 
     */
    create<T extends admin_expert_applicationCreateArgs>(args: SelectSubset<T, admin_expert_applicationCreateArgs<ExtArgs>>): Prisma__admin_expert_applicationClient<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many Admin_expert_applications and returns the data saved in the database.
     * @param {admin_expert_applicationCreateManyAndReturnArgs} args - Arguments to create many Admin_expert_applications.
     * @example
     * // Create many Admin_expert_applications
     * const admin_expert_application = await prisma.admin_expert_application.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Admin_expert_applications and only return the `id`
     * const admin_expert_applicationWithIdOnly = await prisma.admin_expert_application.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends admin_expert_applicationCreateManyAndReturnArgs>(args?: SelectSubset<T, admin_expert_applicationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Admin_expert_application.
     * @param {admin_expert_applicationDeleteArgs} args - Arguments to delete one Admin_expert_application.
     * @example
     * // Delete one Admin_expert_application
     * const Admin_expert_application = await prisma.admin_expert_application.delete({
     *   where: {
     *     // ... filter to delete one Admin_expert_application
     *   }
     * })
     * 
     */
    delete<T extends admin_expert_applicationDeleteArgs>(args: SelectSubset<T, admin_expert_applicationDeleteArgs<ExtArgs>>): Prisma__admin_expert_applicationClient<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Admin_expert_application.
     * @param {admin_expert_applicationUpdateArgs} args - Arguments to update one Admin_expert_application.
     * @example
     * // Update one Admin_expert_application
     * const admin_expert_application = await prisma.admin_expert_application.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends admin_expert_applicationUpdateArgs>(args: SelectSubset<T, admin_expert_applicationUpdateArgs<ExtArgs>>): Prisma__admin_expert_applicationClient<$Result.GetResult<Prisma.$admin_expert_applicationPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a Admin_expert_application.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Admin_expert_applicationAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Admin_expert_applicationAggregateArgs>(args: Subset<T, Admin_expert_applicationAggregateArgs>): Prisma.PrismaPromise<GetAdmin_expert_applicationAggregateType<T>>

    /**
     * Group by Admin_expert_application.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {admin_expert_applicationGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends admin_expert_applicationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: admin_expert_applicationGroupByArgs['orderBy'] }
        : { orderBy?: admin_expert_applicationGroupByArgs['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, admin_expert_applicationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdmin_expert_applicationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the admin_expert_application model
   */
  readonly fields: admin_expert_applicationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for admin_expert_application.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__admin_expert_applicationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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"> | Null, Null, ExtArgs>
    answer<T extends admin_expert_application$answerArgs<ExtArgs> = {}>(args?: Subset<T, admin_expert_application$answerArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findMany"> | 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 admin_expert_application model
   */ 
  interface admin_expert_applicationFieldRefs {
    readonly id: FieldRef<"admin_expert_application", 'String'>
    readonly status: FieldRef<"admin_expert_application", 'Status'>
    readonly createdAt: FieldRef<"admin_expert_application", 'DateTime'>
    readonly userId: FieldRef<"admin_expert_application", 'String'>
  }
    

  // Custom InputTypes
  /**
   * admin_expert_application findUnique
   */
  export type admin_expert_applicationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter, which admin_expert_application to fetch.
     */
    where: admin_expert_applicationWhereUniqueInput
  }

  /**
   * admin_expert_application findUniqueOrThrow
   */
  export type admin_expert_applicationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter, which admin_expert_application to fetch.
     */
    where: admin_expert_applicationWhereUniqueInput
  }

  /**
   * admin_expert_application findFirst
   */
  export type admin_expert_applicationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter, which admin_expert_application to fetch.
     */
    where?: admin_expert_applicationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_expert_applications to fetch.
     */
    orderBy?: admin_expert_applicationOrderByWithRelationInput | admin_expert_applicationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_expert_applications.
     */
    cursor?: admin_expert_applicationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_expert_applications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` admin_expert_applications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_expert_applications.
     */
    distinct?: Admin_expert_applicationScalarFieldEnum | Admin_expert_applicationScalarFieldEnum[]
  }

  /**
   * admin_expert_application findFirstOrThrow
   */
  export type admin_expert_applicationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter, which admin_expert_application to fetch.
     */
    where?: admin_expert_applicationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_expert_applications to fetch.
     */
    orderBy?: admin_expert_applicationOrderByWithRelationInput | admin_expert_applicationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for admin_expert_applications.
     */
    cursor?: admin_expert_applicationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_expert_applications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` admin_expert_applications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of admin_expert_applications.
     */
    distinct?: Admin_expert_applicationScalarFieldEnum | Admin_expert_applicationScalarFieldEnum[]
  }

  /**
   * admin_expert_application findMany
   */
  export type admin_expert_applicationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter, which admin_expert_applications to fetch.
     */
    where?: admin_expert_applicationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of admin_expert_applications to fetch.
     */
    orderBy?: admin_expert_applicationOrderByWithRelationInput | admin_expert_applicationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing admin_expert_applications.
     */
    cursor?: admin_expert_applicationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` admin_expert_applications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` admin_expert_applications.
     */
    skip?: number
    distinct?: Admin_expert_applicationScalarFieldEnum | Admin_expert_applicationScalarFieldEnum[]
  }

  /**
   * admin_expert_application create
   */
  export type admin_expert_applicationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * The data needed to create a admin_expert_application.
     */
    data: XOR<admin_expert_applicationCreateInput, admin_expert_applicationUncheckedCreateInput>
  }

  /**
   * admin_expert_application createMany
   */
  export type admin_expert_applicationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many admin_expert_applications.
     */
    data: admin_expert_applicationCreateManyInput | admin_expert_applicationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * admin_expert_application createManyAndReturn
   */
  export type admin_expert_applicationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many admin_expert_applications.
     */
    data: admin_expert_applicationCreateManyInput | admin_expert_applicationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * admin_expert_application update
   */
  export type admin_expert_applicationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * The data needed to update a admin_expert_application.
     */
    data: XOR<admin_expert_applicationUpdateInput, admin_expert_applicationUncheckedUpdateInput>
    /**
     * Choose, which admin_expert_application to update.
     */
    where: admin_expert_applicationWhereUniqueInput
  }

  /**
   * admin_expert_application updateMany
   */
  export type admin_expert_applicationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update admin_expert_applications.
     */
    data: XOR<admin_expert_applicationUpdateManyMutationInput, admin_expert_applicationUncheckedUpdateManyInput>
    /**
     * Filter which admin_expert_applications to update
     */
    where?: admin_expert_applicationWhereInput
  }

  /**
   * admin_expert_application upsert
   */
  export type admin_expert_applicationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * The filter to search for the admin_expert_application to update in case it exists.
     */
    where: admin_expert_applicationWhereUniqueInput
    /**
     * In case the admin_expert_application found by the `where` argument doesn't exist, create a new admin_expert_application with this data.
     */
    create: XOR<admin_expert_applicationCreateInput, admin_expert_applicationUncheckedCreateInput>
    /**
     * In case the admin_expert_application was found with the provided `where` argument, update it with this data.
     */
    update: XOR<admin_expert_applicationUpdateInput, admin_expert_applicationUncheckedUpdateInput>
  }

  /**
   * admin_expert_application delete
   */
  export type admin_expert_applicationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
    /**
     * Filter which admin_expert_application to delete.
     */
    where: admin_expert_applicationWhereUniqueInput
  }

  /**
   * admin_expert_application deleteMany
   */
  export type admin_expert_applicationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which admin_expert_applications to delete
     */
    where?: admin_expert_applicationWhereInput
  }

  /**
   * admin_expert_application.answer
   */
  export type admin_expert_application$answerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    where?: expertApplicationAnswerWhereInput
    orderBy?: expertApplicationAnswerOrderByWithRelationInput | expertApplicationAnswerOrderByWithRelationInput[]
    cursor?: expertApplicationAnswerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertApplicationAnswerScalarFieldEnum | ExpertApplicationAnswerScalarFieldEnum[]
  }

  /**
   * admin_expert_application without action
   */
  export type admin_expert_applicationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the admin_expert_application
     */
    select?: admin_expert_applicationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: admin_expert_applicationInclude<ExtArgs> | null
  }


  /**
   * Model expertApplicationQuestion
   */

  export type AggregateExpertApplicationQuestion = {
    _count: ExpertApplicationQuestionCountAggregateOutputType | null
    _avg: ExpertApplicationQuestionAvgAggregateOutputType | null
    _sum: ExpertApplicationQuestionSumAggregateOutputType | null
    _min: ExpertApplicationQuestionMinAggregateOutputType | null
    _max: ExpertApplicationQuestionMaxAggregateOutputType | null
  }

  export type ExpertApplicationQuestionAvgAggregateOutputType = {
    order: number | null
  }

  export type ExpertApplicationQuestionSumAggregateOutputType = {
    order: number | null
  }

  export type ExpertApplicationQuestionMinAggregateOutputType = {
    id: string | null
    question: string | null
    created_at: Date | null
    order: number | null
  }

  export type ExpertApplicationQuestionMaxAggregateOutputType = {
    id: string | null
    question: string | null
    created_at: Date | null
    order: number | null
  }

  export type ExpertApplicationQuestionCountAggregateOutputType = {
    id: number
    question: number
    created_at: number
    order: number
    _all: number
  }


  export type ExpertApplicationQuestionAvgAggregateInputType = {
    order?: true
  }

  export type ExpertApplicationQuestionSumAggregateInputType = {
    order?: true
  }

  export type ExpertApplicationQuestionMinAggregateInputType = {
    id?: true
    question?: true
    created_at?: true
    order?: true
  }

  export type ExpertApplicationQuestionMaxAggregateInputType = {
    id?: true
    question?: true
    created_at?: true
    order?: true
  }

  export type ExpertApplicationQuestionCountAggregateInputType = {
    id?: true
    question?: true
    created_at?: true
    order?: true
    _all?: true
  }

  export type ExpertApplicationQuestionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which expertApplicationQuestion to aggregate.
     */
    where?: expertApplicationQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of expertApplicationQuestions to fetch.
     */
    orderBy?: expertApplicationQuestionOrderByWithRelationInput | expertApplicationQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: expertApplicationQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` expertApplicationQuestions 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` expertApplicationQuestions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned expertApplicationQuestions
    **/
    _count?: true | ExpertApplicationQuestionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExpertApplicationQuestionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExpertApplicationQuestionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExpertApplicationQuestionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExpertApplicationQuestionMaxAggregateInputType
  }

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




  export type expertApplicationQuestionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: expertApplicationQuestionWhereInput
    orderBy?: expertApplicationQuestionOrderByWithAggregationInput | expertApplicationQuestionOrderByWithAggregationInput[]
    by: ExpertApplicationQuestionScalarFieldEnum[] | ExpertApplicationQuestionScalarFieldEnum
    having?: expertApplicationQuestionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertApplicationQuestionCountAggregateInputType | true
    _avg?: ExpertApplicationQuestionAvgAggregateInputType
    _sum?: ExpertApplicationQuestionSumAggregateInputType
    _min?: ExpertApplicationQuestionMinAggregateInputType
    _max?: ExpertApplicationQuestionMaxAggregateInputType
  }

  export type ExpertApplicationQuestionGroupByOutputType = {
    id: string
    question: string
    created_at: Date
    order: number
    _count: ExpertApplicationQuestionCountAggregateOutputType | null
    _avg: ExpertApplicationQuestionAvgAggregateOutputType | null
    _sum: ExpertApplicationQuestionSumAggregateOutputType | null
    _min: ExpertApplicationQuestionMinAggregateOutputType | null
    _max: ExpertApplicationQuestionMaxAggregateOutputType | null
  }

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


  export type expertApplicationQuestionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    question?: boolean
    created_at?: boolean
    order?: boolean
    expertApplicationAnswer?: boolean | expertApplicationQuestion$expertApplicationAnswerArgs<ExtArgs>
    _count?: boolean | ExpertApplicationQuestionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["expertApplicationQuestion"]>

  export type expertApplicationQuestionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    question?: boolean
    created_at?: boolean
    order?: boolean
  }, ExtArgs["result"]["expertApplicationQuestion"]>

  export type expertApplicationQuestionSelectScalar = {
    id?: boolean
    question?: boolean
    created_at?: boolean
    order?: boolean
  }

  export type expertApplicationQuestionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    expertApplicationAnswer?: boolean | expertApplicationQuestion$expertApplicationAnswerArgs<ExtArgs>
    _count?: boolean | ExpertApplicationQuestionCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type expertApplicationQuestionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $expertApplicationQuestionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "expertApplicationQuestion"
    objects: {
      expertApplicationAnswer: Prisma.$expertApplicationAnswerPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      question: string
      created_at: Date
      order: number
    }, ExtArgs["result"]["expertApplicationQuestion"]>
    composites: {}
  }

  type expertApplicationQuestionGetPayload<S extends boolean | null | undefined | expertApplicationQuestionDefaultArgs> = $Result.GetResult<Prisma.$expertApplicationQuestionPayload, S>

  type expertApplicationQuestionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<expertApplicationQuestionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExpertApplicationQuestionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ExpertApplicationQuestion 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 {expertApplicationQuestionFindFirstArgs} args - Arguments to find a ExpertApplicationQuestion
     * @example
     * // Get one ExpertApplicationQuestion
     * const expertApplicationQuestion = await prisma.expertApplicationQuestion.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends expertApplicationQuestionFindFirstArgs>(args?: SelectSubset<T, expertApplicationQuestionFindFirstArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ExpertApplicationQuestion 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 {expertApplicationQuestionFindFirstOrThrowArgs} args - Arguments to find a ExpertApplicationQuestion
     * @example
     * // Get one ExpertApplicationQuestion
     * const expertApplicationQuestion = await prisma.expertApplicationQuestion.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends expertApplicationQuestionFindFirstOrThrowArgs>(args?: SelectSubset<T, expertApplicationQuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ExpertApplicationQuestions 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 {expertApplicationQuestionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ExpertApplicationQuestions
     * const expertApplicationQuestions = await prisma.expertApplicationQuestion.findMany()
     * 
     * // Get first 10 ExpertApplicationQuestions
     * const expertApplicationQuestions = await prisma.expertApplicationQuestion.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const expertApplicationQuestionWithIdOnly = await prisma.expertApplicationQuestion.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends expertApplicationQuestionFindManyArgs>(args?: SelectSubset<T, expertApplicationQuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ExpertApplicationQuestion.
     * @param {expertApplicationQuestionCreateArgs} args - Arguments to create a ExpertApplicationQuestion.
     * @example
     * // Create one ExpertApplicationQuestion
     * const ExpertApplicationQuestion = await prisma.expertApplicationQuestion.create({
     *   data: {
     *     // ... data to create a ExpertApplicationQuestion
     *   }
     * })
     * 
     */
    create<T extends expertApplicationQuestionCreateArgs>(args: SelectSubset<T, expertApplicationQuestionCreateArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many ExpertApplicationQuestions and returns the data saved in the database.
     * @param {expertApplicationQuestionCreateManyAndReturnArgs} args - Arguments to create many ExpertApplicationQuestions.
     * @example
     * // Create many ExpertApplicationQuestions
     * const expertApplicationQuestion = await prisma.expertApplicationQuestion.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ExpertApplicationQuestions and only return the `id`
     * const expertApplicationQuestionWithIdOnly = await prisma.expertApplicationQuestion.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends expertApplicationQuestionCreateManyAndReturnArgs>(args?: SelectSubset<T, expertApplicationQuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a ExpertApplicationQuestion.
     * @param {expertApplicationQuestionDeleteArgs} args - Arguments to delete one ExpertApplicationQuestion.
     * @example
     * // Delete one ExpertApplicationQuestion
     * const ExpertApplicationQuestion = await prisma.expertApplicationQuestion.delete({
     *   where: {
     *     // ... filter to delete one ExpertApplicationQuestion
     *   }
     * })
     * 
     */
    delete<T extends expertApplicationQuestionDeleteArgs>(args: SelectSubset<T, expertApplicationQuestionDeleteArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ExpertApplicationQuestion.
     * @param {expertApplicationQuestionUpdateArgs} args - Arguments to update one ExpertApplicationQuestion.
     * @example
     * // Update one ExpertApplicationQuestion
     * const expertApplicationQuestion = await prisma.expertApplicationQuestion.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends expertApplicationQuestionUpdateArgs>(args: SelectSubset<T, expertApplicationQuestionUpdateArgs<ExtArgs>>): Prisma__expertApplicationQuestionClient<$Result.GetResult<Prisma.$expertApplicationQuestionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

    /**
     * Group by ExpertApplicationQuestion.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {expertApplicationQuestionGroupByArgs} 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 expertApplicationQuestionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: expertApplicationQuestionGroupByArgs['orderBy'] }
        : { orderBy?: expertApplicationQuestionGroupByArgs['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, expertApplicationQuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExpertApplicationQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the expertApplicationQuestion model
   */
  readonly fields: expertApplicationQuestionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for expertApplicationQuestion.
   * 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__expertApplicationQuestionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    expertApplicationAnswer<T extends expertApplicationQuestion$expertApplicationAnswerArgs<ExtArgs> = {}>(args?: Subset<T, expertApplicationQuestion$expertApplicationAnswerArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$expertApplicationAnswerPayload<ExtArgs>, T, "findMany"> | 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 expertApplicationQuestion model
   */ 
  interface expertApplicationQuestionFieldRefs {
    readonly id: FieldRef<"expertApplicationQuestion", 'String'>
    readonly question: FieldRef<"expertApplicationQuestion", 'String'>
    readonly created_at: FieldRef<"expertApplicationQuestion", 'DateTime'>
    readonly order: FieldRef<"expertApplicationQuestion", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * expertApplicationQuestion findUnique
   */
  export type expertApplicationQuestionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationQuestion to fetch.
     */
    where: expertApplicationQuestionWhereUniqueInput
  }

  /**
   * expertApplicationQuestion findUniqueOrThrow
   */
  export type expertApplicationQuestionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationQuestion to fetch.
     */
    where: expertApplicationQuestionWhereUniqueInput
  }

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

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

  /**
   * expertApplicationQuestion findMany
   */
  export type expertApplicationQuestionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * Filter, which expertApplicationQuestions to fetch.
     */
    where?: expertApplicationQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of expertApplicationQuestions to fetch.
     */
    orderBy?: expertApplicationQuestionOrderByWithRelationInput | expertApplicationQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing expertApplicationQuestions.
     */
    cursor?: expertApplicationQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` expertApplicationQuestions 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` expertApplicationQuestions.
     */
    skip?: number
    distinct?: ExpertApplicationQuestionScalarFieldEnum | ExpertApplicationQuestionScalarFieldEnum[]
  }

  /**
   * expertApplicationQuestion create
   */
  export type expertApplicationQuestionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * The data needed to create a expertApplicationQuestion.
     */
    data: XOR<expertApplicationQuestionCreateInput, expertApplicationQuestionUncheckedCreateInput>
  }

  /**
   * expertApplicationQuestion createMany
   */
  export type expertApplicationQuestionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many expertApplicationQuestions.
     */
    data: expertApplicationQuestionCreateManyInput | expertApplicationQuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * expertApplicationQuestion createManyAndReturn
   */
  export type expertApplicationQuestionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many expertApplicationQuestions.
     */
    data: expertApplicationQuestionCreateManyInput | expertApplicationQuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * expertApplicationQuestion update
   */
  export type expertApplicationQuestionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * The data needed to update a expertApplicationQuestion.
     */
    data: XOR<expertApplicationQuestionUpdateInput, expertApplicationQuestionUncheckedUpdateInput>
    /**
     * Choose, which expertApplicationQuestion to update.
     */
    where: expertApplicationQuestionWhereUniqueInput
  }

  /**
   * expertApplicationQuestion updateMany
   */
  export type expertApplicationQuestionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update expertApplicationQuestions.
     */
    data: XOR<expertApplicationQuestionUpdateManyMutationInput, expertApplicationQuestionUncheckedUpdateManyInput>
    /**
     * Filter which expertApplicationQuestions to update
     */
    where?: expertApplicationQuestionWhereInput
  }

  /**
   * expertApplicationQuestion upsert
   */
  export type expertApplicationQuestionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * The filter to search for the expertApplicationQuestion to update in case it exists.
     */
    where: expertApplicationQuestionWhereUniqueInput
    /**
     * In case the expertApplicationQuestion found by the `where` argument doesn't exist, create a new expertApplicationQuestion with this data.
     */
    create: XOR<expertApplicationQuestionCreateInput, expertApplicationQuestionUncheckedCreateInput>
    /**
     * In case the expertApplicationQuestion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<expertApplicationQuestionUpdateInput, expertApplicationQuestionUncheckedUpdateInput>
  }

  /**
   * expertApplicationQuestion delete
   */
  export type expertApplicationQuestionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<ExtArgs> | null
    /**
     * Filter which expertApplicationQuestion to delete.
     */
    where: expertApplicationQuestionWhereUniqueInput
  }

  /**
   * expertApplicationQuestion deleteMany
   */
  export type expertApplicationQuestionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which expertApplicationQuestions to delete
     */
    where?: expertApplicationQuestionWhereInput
  }

  /**
   * expertApplicationQuestion.expertApplicationAnswer
   */
  export type expertApplicationQuestion$expertApplicationAnswerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationAnswer
     */
    select?: expertApplicationAnswerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationAnswerInclude<ExtArgs> | null
    where?: expertApplicationAnswerWhereInput
    orderBy?: expertApplicationAnswerOrderByWithRelationInput | expertApplicationAnswerOrderByWithRelationInput[]
    cursor?: expertApplicationAnswerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExpertApplicationAnswerScalarFieldEnum | ExpertApplicationAnswerScalarFieldEnum[]
  }

  /**
   * expertApplicationQuestion without action
   */
  export type expertApplicationQuestionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the expertApplicationQuestion
     */
    select?: expertApplicationQuestionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: expertApplicationQuestionInclude<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',
    firstName: 'firstName',
    lastName: 'lastName',
    email: 'email',
    imageUrl: 'imageUrl',
    imageName: 'imageName',
    customer_id: 'customer_id',
    phone: 'phone',
    follower: 'follower',
    role: 'role',
    state: 'state',
    city: 'city',
    zipcode: 'zipcode',
    timezone: 'timezone',
    rate: 'rate',
    countryOfResidence: 'countryOfResidence',
    biography: 'biography',
    linkedInURL: 'linkedInURL',
    instagramURL: 'instagramURL',
    youtubeURL: 'youtubeURL',
    spotifyURL: 'spotifyURL',
    tiktokURL: 'tiktokURL',
    twitterURL: 'twitterURL',
    amazonURL: 'amazonURL',
    websiteURL1: 'websiteURL1',
    websiteURL2: 'websiteURL2',
    createdAt: 'createdAt',
    refresh_token: 'refresh_token',
    isExpert: 'isExpert',
    videos: 'videos',
    expertId: 'expertId',
    provider: 'provider',
    otherInfo: 'otherInfo',
    is_invited: 'is_invited',
    userName: 'userName',
    isBanned: 'isBanned',
    isAdmin: 'isAdmin',
    isSubscribed: 'isSubscribed',
    countryOfResidenceISO: 'countryOfResidenceISO',
    countryOfResidenceId: 'countryOfResidenceId',
    dateOfBirth: 'dateOfBirth',
    emailVerified: 'emailVerified',
    idVerified: 'idVerified',
    FavoriteExpertIds: 'FavoriteExpertIds'
  };

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


  export const ExpertScalarFieldEnum: {
    id: 'id',
    stripeAccountId: 'stripeAccountId',
    rate: 'rate',
    timezone: 'timezone',
    user_id: 'user_id',
    isAccepted: 'isAccepted',
    countryOfResidenceId: 'countryOfResidenceId',
    created_at: 'created_at',
    firstName: 'firstName',
    lastName: 'lastName',
    email: 'email'
  };

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


  export const Id_verificationScalarFieldEnum: {
    id: 'id',
    status: 'status',
    userId: 'userId',
    idImageUrlBack: 'idImageUrlBack',
    idImageUrlFront: 'idImageUrlFront',
    createdAt: 'createdAt',
    documentType: 'documentType'
  };

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


  export const Email_verification_tokenScalarFieldEnum: {
    id: 'id',
    expires: 'expires',
    userId: 'userId'
  };

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


  export const QuestionScalarFieldEnum: {
    id: 'id',
    content: 'content',
    userId: 'userId'
  };

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


  export const ReplyScalarFieldEnum: {
    id: 'id',
    content: 'content',
    appointmentKey: 'appointmentKey',
    questionContent: 'questionContent',
    userId: 'userId'
  };

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


  export const StripeAccountScalarFieldEnum: {
    id: 'id',
    stripeData: 'stripeData',
    expertId: 'expertId'
  };

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


  export const KeyScalarFieldEnum: {
    id: 'id',
    hashed_password: 'hashed_password',
    user_id: 'user_id'
  };

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


  export const ExperienceScalarFieldEnum: {
    id: 'id',
    companyName: 'companyName',
    role: 'role',
    isCurrent: 'isCurrent',
    duration: 'duration',
    description: 'description',
    userId: 'userId',
    endDate: 'endDate',
    startDate: 'startDate'
  };

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


  export const EducationScalarFieldEnum: {
    id: 'id',
    institutionName: 'institutionName',
    diplomaTitle: 'diplomaTitle',
    fieldOfStudy: 'fieldOfStudy',
    isCurrent: 'isCurrent',
    duration: 'duration',
    userId: 'userId',
    startDate: 'startDate',
    endDate: 'endDate'
  };

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


  export const ExpertiseScalarFieldEnum: {
    id: 'id',
    field: 'field',
    isCurrent: 'isCurrent',
    description: 'description',
    duration: 'duration',
    userId: 'userId',
    startDate: 'startDate',
    endDate: 'endDate'
  };

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


  export const LanguageScalarFieldEnum: {
    id: 'id',
    name: 'name',
    userId: 'userId'
  };

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


  export const AppointmentScalarFieldEnum: {
    id: 'id',
    clientId: 'clientId',
    clientEmail: 'clientEmail',
    expertId: 'expertId',
    clientName: 'clientName',
    expertName: 'expertName',
    isAcceptedByExpert: 'isAcceptedByExpert',
    price: 'price',
    timezone: 'timezone',
    date: 'date',
    dayName: 'dayName',
    time: 'time',
    text: 'text',
    createdAt: 'createdAt',
    videoRoomId: 'videoRoomId',
    appointmentKey: 'appointmentKey',
    paymentStatus: 'paymentStatus',
    paymentIntentId: 'paymentIntentId',
    sessionId: 'sessionId',
    authorizedDate: 'authorizedDate',
    appointementKeyInExpertTimeZone: 'appointementKeyInExpertTimeZone',
    appointementKeyInClientTimeZone: 'appointementKeyInClientTimeZone',
    bookedAppointments: 'bookedAppointments',
    status: 'status',
    reason: 'reason'
  };

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


  export const AvailabilityScalarFieldEnum: {
    id: 'id',
    day: 'day',
    timezone: 'timezone',
    expertId: 'expertId',
    userId: 'userId'
  };

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


  export const SlotScalarFieldEnum: {
    id: 'id',
    start: 'start',
    end: 'end',
    recurring: 'recurring',
    availabilityId: 'availabilityId',
    hide: 'hide',
    isSplit: 'isSplit',
    originalId: 'originalId'
  };

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


  export const ExceptionScalarFieldEnum: {
    id: 'id',
    date: 'date',
    slotId: 'slotId'
  };

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


  export const ChatScalarFieldEnum: {
    id: 'id',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    clientId: 'clientId',
    expertId: 'expertId'
  };

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


  export const ChatMessageScalarFieldEnum: {
    id: 'id',
    content: 'content',
    userId: 'userId',
    fileName: 'fileName',
    type: 'type',
    fileType: 'fileType',
    fileUrl: 'fileUrl',
    createdAt: 'createdAt',
    chatId: 'chatId',
    senderId: 'senderId',
    expertId: 'expertId'
  };

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


  export const ClientReviewScalarFieldEnum: {
    id: 'id',
    reviewText: 'reviewText',
    createdAt: 'createdAt',
    videoRoomId: 'videoRoomId',
    appointmentKey: 'appointmentKey',
    isDisplayed: 'isDisplayed',
    clientId: 'clientId',
    expertId: 'expertId'
  };

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


  export const ExpertReviewScalarFieldEnum: {
    id: 'id',
    reviewText: 'reviewText',
    createdAt: 'createdAt',
    videoRoomId: 'videoRoomId',
    expertId: 'expertId',
    appointmentKey: 'appointmentKey',
    isDisplayed: 'isDisplayed',
    clientId: 'clientId'
  };

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


  export const Admin_invite_expertsScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    created_at: 'created_at',
    email: 'email',
    status: 'status'
  };

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


  export const Admin_mbc_cmsScalarFieldEnum: {
    id: 'id',
    created_at: 'created_at',
    section1_text: 'section1_text',
    section1_image: 'section1_image',
    section2_text: 'section2_text',
    section2_image: 'section2_image',
    about_us_title: 'about_us_title',
    about_us_desc: 'about_us_desc',
    general_condition_of_use: 'general_condition_of_use',
    general_condition_of_sales: 'general_condition_of_sales',
    is_active: 'is_active',
    invite_email_content: 'invite_email_content',
    invite_email_subject: 'invite_email_subject'
  };

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


  export const Admin_mbc_faqsScalarFieldEnum: {
    id: 'id',
    created_at: 'created_at',
    question_title: 'question_title',
    question_desc: 'question_desc'
  };

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


  export const Admin_newsletterScalarFieldEnum: {
    id: 'id',
    created_at: 'created_at',
    email: 'email',
    isUser: 'isUser',
    name: 'name'
  };

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


  export const Admin_userScalarFieldEnum: {
    id: 'id',
    created_at: 'created_at',
    role: 'role',
    user_id: 'user_id'
  };

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


  export const FaqQuestionScalarFieldEnum: {
    id: 'id',
    question: 'question',
    answer: 'answer',
    created_at: 'created_at'
  };

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


  export const SessionScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    active_expires: 'active_expires',
    idle_expires: 'idle_expires'
  };

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


  export const Admin_editingScalarFieldEnum: {
    id: 'id',
    updatedAt: 'updatedAt',
    genericEmailBody: 'genericEmailBody',
    genericEmailHeader: 'genericEmailHeader',
    aboutContent: 'aboutContent',
    aboutImageUrl: 'aboutImageUrl',
    landingPageDesc: 'landingPageDesc',
    landingPageHeading: 'landingPageHeading',
    landingPageHero: 'landingPageHero',
    landingPageSectionDesc: 'landingPageSectionDesc',
    landingPageSectionHeading: 'landingPageSectionHeading',
    landingPageSectionHero: 'landingPageSectionHero',
    conditionsSale: 'conditionsSale',
    conditionsUse: 'conditionsUse',
    privacyPolicy: 'privacyPolicy'
  };

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


  export const Admin_notificationScalarFieldEnum: {
    id: 'id',
    created_at: 'created_at',
    title: 'title',
    link: 'link',
    description: 'description'
  };

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


  export const Admin_notification_statusScalarFieldEnum: {
    id: 'id',
    status: 'status',
    newExpertApplication: 'newExpertApplication',
    newInvitationAccepted: 'newInvitationAccepted',
    newIdVerification: 'newIdVerification'
  };

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


  export const ExpertApplicationAnswerScalarFieldEnum: {
    id: 'id',
    answer: 'answer',
    created_at: 'created_at',
    userId: 'userId',
    questionId: 'questionId',
    admin_expert_applicationId: 'admin_expert_applicationId'
  };

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


  export const Admin_expert_applicationScalarFieldEnum: {
    id: 'id',
    status: 'status',
    createdAt: 'createdAt',
    userId: 'userId'
  };

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


  export const ExpertApplicationQuestionScalarFieldEnum: {
    id: 'id',
    question: 'question',
    created_at: 'created_at',
    order: 'order'
  };

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


  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 JsonNullValueInput: {
    JsonNull: typeof JsonNull
  };

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


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

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


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

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


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

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


  /**
   * Field references 
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'String[]'
   */
  export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'Int[]'
   */
  export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'CountryCode'
   */
  export type EnumCountryCodeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CountryCode'>
    


  /**
   * Reference to a field of type 'CountryCode[]'
   */
  export type ListEnumCountryCodeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CountryCode[]'>
    


  /**
   * Reference to a field of type 'Status'
   */
  export type EnumStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Status'>
    


  /**
   * Reference to a field of type 'Status[]'
   */
  export type ListEnumStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Status[]'>
    


  /**
   * Reference to a field of type 'documentType'
   */
  export type EnumdocumentTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'documentType'>
    


  /**
   * Reference to a field of type 'documentType[]'
   */
  export type ListEnumdocumentTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'documentType[]'>
    


  /**
   * Reference to a field of type 'BigInt'
   */
  export type BigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt'>
    


  /**
   * Reference to a field of type 'BigInt[]'
   */
  export type ListBigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt[]'>
    


  /**
   * Reference to a field of type 'INVITE_STATUS'
   */
  export type EnumINVITE_STATUSFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'INVITE_STATUS'>
    


  /**
   * Reference to a field of type 'INVITE_STATUS[]'
   */
  export type ListEnumINVITE_STATUSFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'INVITE_STATUS[]'>
    


  /**
   * Reference to a field of type 'AdminRole'
   */
  export type EnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole'>
    


  /**
   * Reference to a field of type 'AdminRole[]'
   */
  export type ListEnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole[]'>
    


  /**
   * Reference to a field of type 'NotificationStatus'
   */
  export type EnumNotificationStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationStatus'>
    


  /**
   * Reference to a field of type 'NotificationStatus[]'
   */
  export type ListEnumNotificationStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationStatus[]'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    
  /**
   * Deep Input Types
   */


  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    firstName?: StringNullableFilter<"User"> | string | null
    lastName?: StringNullableFilter<"User"> | string | null
    email?: StringFilter<"User"> | string
    imageUrl?: StringNullableFilter<"User"> | string | null
    imageName?: StringNullableFilter<"User"> | string | null
    customer_id?: StringNullableFilter<"User"> | string | null
    phone?: StringNullableFilter<"User"> | string | null
    follower?: IntNullableFilter<"User"> | number | null
    role?: StringNullableFilter<"User"> | string | null
    state?: StringNullableFilter<"User"> | string | null
    city?: StringNullableFilter<"User"> | string | null
    zipcode?: StringNullableFilter<"User"> | string | null
    timezone?: StringNullableFilter<"User"> | string | null
    rate?: StringNullableFilter<"User"> | string | null
    countryOfResidence?: StringNullableFilter<"User"> | string | null
    biography?: StringNullableFilter<"User"> | string | null
    linkedInURL?: StringNullableFilter<"User"> | string | null
    instagramURL?: StringNullableFilter<"User"> | string | null
    youtubeURL?: StringNullableFilter<"User"> | string | null
    spotifyURL?: StringNullableFilter<"User"> | string | null
    tiktokURL?: StringNullableFilter<"User"> | string | null
    twitterURL?: StringNullableFilter<"User"> | string | null
    amazonURL?: StringNullableFilter<"User"> | string | null
    websiteURL1?: StringNullableFilter<"User"> | string | null
    websiteURL2?: StringNullableFilter<"User"> | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    refresh_token?: StringNullableFilter<"User"> | string | null
    isExpert?: BoolFilter<"User"> | boolean
    videos?: StringNullableListFilter<"User">
    expertId?: StringFilter<"User"> | string
    provider?: StringNullableFilter<"User"> | string | null
    otherInfo?: JsonNullableFilter<"User">
    is_invited?: IntNullableFilter<"User"> | number | null
    userName?: StringNullableFilter<"User"> | string | null
    isBanned?: BoolFilter<"User"> | boolean
    isAdmin?: BoolFilter<"User"> | boolean
    isSubscribed?: BoolFilter<"User"> | boolean
    countryOfResidenceISO?: EnumCountryCodeFilter<"User"> | $Enums.CountryCode
    countryOfResidenceId?: IntNullableFilter<"User"> | number | null
    dateOfBirth?: DateTimeNullableFilter<"User"> | Date | string | null
    emailVerified?: BoolFilter<"User"> | boolean
    idVerified?: BoolFilter<"User"> | boolean
    FavoriteExpertIds?: StringNullableListFilter<"User">
    Appointment?: AppointmentListRelationFilter
    availabilities?: AvailabilityListRelationFilter
    Chat?: ChatListRelationFilter
    messages?: ChatMessageListRelationFilter
    receivedClientReviews?: ClientReviewListRelationFilter
    educations?: EducationListRelationFilter
    experiences?: ExperienceListRelationFilter
    Expert?: XOR<ExpertNullableRelationFilter, ExpertWhereInput> | null
    writtenExpertReviews?: ExpertReviewListRelationFilter
    expertises?: ExpertiseListRelationFilter
    key?: KeyListRelationFilter
    languagesSpoken?: LanguageListRelationFilter
    Questions?: QuestionListRelationFilter
    reply?: ReplyListRelationFilter
    admin_expert_application?: Admin_expert_applicationListRelationFilter
    admin_user?: XOR<Admin_userNullableRelationFilter, admin_userWhereInput> | null
    email_verification_token?: Email_verification_tokenListRelationFilter
    expertApplicationAnswer?: ExpertApplicationAnswerListRelationFilter
    id_verification?: Id_verificationListRelationFilter
    session?: SessionListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    email?: SortOrder
    imageUrl?: SortOrderInput | SortOrder
    imageName?: SortOrderInput | SortOrder
    customer_id?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    follower?: SortOrderInput | SortOrder
    role?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    zipcode?: SortOrderInput | SortOrder
    timezone?: SortOrderInput | SortOrder
    rate?: SortOrderInput | SortOrder
    countryOfResidence?: SortOrderInput | SortOrder
    biography?: SortOrderInput | SortOrder
    linkedInURL?: SortOrderInput | SortOrder
    instagramURL?: SortOrderInput | SortOrder
    youtubeURL?: SortOrderInput | SortOrder
    spotifyURL?: SortOrderInput | SortOrder
    tiktokURL?: SortOrderInput | SortOrder
    twitterURL?: SortOrderInput | SortOrder
    amazonURL?: SortOrderInput | SortOrder
    websiteURL1?: SortOrderInput | SortOrder
    websiteURL2?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    refresh_token?: SortOrderInput | SortOrder
    isExpert?: SortOrder
    videos?: SortOrder
    expertId?: SortOrder
    provider?: SortOrderInput | SortOrder
    otherInfo?: SortOrderInput | SortOrder
    is_invited?: SortOrderInput | SortOrder
    userName?: SortOrderInput | SortOrder
    isBanned?: SortOrder
    isAdmin?: SortOrder
    isSubscribed?: SortOrder
    countryOfResidenceISO?: SortOrder
    countryOfResidenceId?: SortOrderInput | SortOrder
    dateOfBirth?: SortOrderInput | SortOrder
    emailVerified?: SortOrder
    idVerified?: SortOrder
    FavoriteExpertIds?: SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    availabilities?: AvailabilityOrderByRelationAggregateInput
    Chat?: ChatOrderByRelationAggregateInput
    messages?: ChatMessageOrderByRelationAggregateInput
    receivedClientReviews?: ClientReviewOrderByRelationAggregateInput
    educations?: EducationOrderByRelationAggregateInput
    experiences?: ExperienceOrderByRelationAggregateInput
    Expert?: ExpertOrderByWithRelationInput
    writtenExpertReviews?: ExpertReviewOrderByRelationAggregateInput
    expertises?: ExpertiseOrderByRelationAggregateInput
    key?: KeyOrderByRelationAggregateInput
    languagesSpoken?: LanguageOrderByRelationAggregateInput
    Questions?: QuestionOrderByRelationAggregateInput
    reply?: ReplyOrderByRelationAggregateInput
    admin_expert_application?: admin_expert_applicationOrderByRelationAggregateInput
    admin_user?: admin_userOrderByWithRelationInput
    email_verification_token?: email_verification_tokenOrderByRelationAggregateInput
    expertApplicationAnswer?: expertApplicationAnswerOrderByRelationAggregateInput
    id_verification?: id_verificationOrderByRelationAggregateInput
    session?: sessionOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    firstName?: StringNullableFilter<"User"> | string | null
    lastName?: StringNullableFilter<"User"> | string | null
    imageUrl?: StringNullableFilter<"User"> | string | null
    imageName?: StringNullableFilter<"User"> | string | null
    customer_id?: StringNullableFilter<"User"> | string | null
    phone?: StringNullableFilter<"User"> | string | null
    follower?: IntNullableFilter<"User"> | number | null
    role?: StringNullableFilter<"User"> | string | null
    state?: StringNullableFilter<"User"> | string | null
    city?: StringNullableFilter<"User"> | string | null
    zipcode?: StringNullableFilter<"User"> | string | null
    timezone?: StringNullableFilter<"User"> | string | null
    rate?: StringNullableFilter<"User"> | string | null
    countryOfResidence?: StringNullableFilter<"User"> | string | null
    biography?: StringNullableFilter<"User"> | string | null
    linkedInURL?: StringNullableFilter<"User"> | string | null
    instagramURL?: StringNullableFilter<"User"> | string | null
    youtubeURL?: StringNullableFilter<"User"> | string | null
    spotifyURL?: StringNullableFilter<"User"> | string | null
    tiktokURL?: StringNullableFilter<"User"> | string | null
    twitterURL?: StringNullableFilter<"User"> | string | null
    amazonURL?: StringNullableFilter<"User"> | string | null
    websiteURL1?: StringNullableFilter<"User"> | string | null
    websiteURL2?: StringNullableFilter<"User"> | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    refresh_token?: StringNullableFilter<"User"> | string | null
    isExpert?: BoolFilter<"User"> | boolean
    videos?: StringNullableListFilter<"User">
    expertId?: StringFilter<"User"> | string
    provider?: StringNullableFilter<"User"> | string | null
    otherInfo?: JsonNullableFilter<"User">
    is_invited?: IntNullableFilter<"User"> | number | null
    userName?: StringNullableFilter<"User"> | string | null
    isBanned?: BoolFilter<"User"> | boolean
    isAdmin?: BoolFilter<"User"> | boolean
    isSubscribed?: BoolFilter<"User"> | boolean
    countryOfResidenceISO?: EnumCountryCodeFilter<"User"> | $Enums.CountryCode
    countryOfResidenceId?: IntNullableFilter<"User"> | number | null
    dateOfBirth?: DateTimeNullableFilter<"User"> | Date | string | null
    emailVerified?: BoolFilter<"User"> | boolean
    idVerified?: BoolFilter<"User"> | boolean
    FavoriteExpertIds?: StringNullableListFilter<"User">
    Appointment?: AppointmentListRelationFilter
    availabilities?: AvailabilityListRelationFilter
    Chat?: ChatListRelationFilter
    messages?: ChatMessageListRelationFilter
    receivedClientReviews?: ClientReviewListRelationFilter
    educations?: EducationListRelationFilter
    experiences?: ExperienceListRelationFilter
    Expert?: XOR<ExpertNullableRelationFilter, ExpertWhereInput> | null
    writtenExpertReviews?: ExpertReviewListRelationFilter
    expertises?: ExpertiseListRelationFilter
    key?: KeyListRelationFilter
    languagesSpoken?: LanguageListRelationFilter
    Questions?: QuestionListRelationFilter
    reply?: ReplyListRelationFilter
    admin_expert_application?: Admin_expert_applicationListRelationFilter
    admin_user?: XOR<Admin_userNullableRelationFilter, admin_userWhereInput> | null
    email_verification_token?: Email_verification_tokenListRelationFilter
    expertApplicationAnswer?: ExpertApplicationAnswerListRelationFilter
    id_verification?: Id_verificationListRelationFilter
    session?: SessionListRelationFilter
  }, "id" | "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    email?: SortOrder
    imageUrl?: SortOrderInput | SortOrder
    imageName?: SortOrderInput | SortOrder
    customer_id?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    follower?: SortOrderInput | SortOrder
    role?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    zipcode?: SortOrderInput | SortOrder
    timezone?: SortOrderInput | SortOrder
    rate?: SortOrderInput | SortOrder
    countryOfResidence?: SortOrderInput | SortOrder
    biography?: SortOrderInput | SortOrder
    linkedInURL?: SortOrderInput | SortOrder
    instagramURL?: SortOrderInput | SortOrder
    youtubeURL?: SortOrderInput | SortOrder
    spotifyURL?: SortOrderInput | SortOrder
    tiktokURL?: SortOrderInput | SortOrder
    twitterURL?: SortOrderInput | SortOrder
    amazonURL?: SortOrderInput | SortOrder
    websiteURL1?: SortOrderInput | SortOrder
    websiteURL2?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    refresh_token?: SortOrderInput | SortOrder
    isExpert?: SortOrder
    videos?: SortOrder
    expertId?: SortOrder
    provider?: SortOrderInput | SortOrder
    otherInfo?: SortOrderInput | SortOrder
    is_invited?: SortOrderInput | SortOrder
    userName?: SortOrderInput | SortOrder
    isBanned?: SortOrder
    isAdmin?: SortOrder
    isSubscribed?: SortOrder
    countryOfResidenceISO?: SortOrder
    countryOfResidenceId?: SortOrderInput | SortOrder
    dateOfBirth?: SortOrderInput | SortOrder
    emailVerified?: SortOrder
    idVerified?: SortOrder
    FavoriteExpertIds?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _avg?: UserAvgOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
    _sum?: UserSumOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    firstName?: StringNullableWithAggregatesFilter<"User"> | string | null
    lastName?: StringNullableWithAggregatesFilter<"User"> | string | null
    email?: StringWithAggregatesFilter<"User"> | string
    imageUrl?: StringNullableWithAggregatesFilter<"User"> | string | null
    imageName?: StringNullableWithAggregatesFilter<"User"> | string | null
    customer_id?: StringNullableWithAggregatesFilter<"User"> | string | null
    phone?: StringNullableWithAggregatesFilter<"User"> | string | null
    follower?: IntNullableWithAggregatesFilter<"User"> | number | null
    role?: StringNullableWithAggregatesFilter<"User"> | string | null
    state?: StringNullableWithAggregatesFilter<"User"> | string | null
    city?: StringNullableWithAggregatesFilter<"User"> | string | null
    zipcode?: StringNullableWithAggregatesFilter<"User"> | string | null
    timezone?: StringNullableWithAggregatesFilter<"User"> | string | null
    rate?: StringNullableWithAggregatesFilter<"User"> | string | null
    countryOfResidence?: StringNullableWithAggregatesFilter<"User"> | string | null
    biography?: StringNullableWithAggregatesFilter<"User"> | string | null
    linkedInURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    instagramURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    youtubeURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    spotifyURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    tiktokURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    twitterURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    amazonURL?: StringNullableWithAggregatesFilter<"User"> | string | null
    websiteURL1?: StringNullableWithAggregatesFilter<"User"> | string | null
    websiteURL2?: StringNullableWithAggregatesFilter<"User"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    refresh_token?: StringNullableWithAggregatesFilter<"User"> | string | null
    isExpert?: BoolWithAggregatesFilter<"User"> | boolean
    videos?: StringNullableListFilter<"User">
    expertId?: StringWithAggregatesFilter<"User"> | string
    provider?: StringNullableWithAggregatesFilter<"User"> | string | null
    otherInfo?: JsonNullableWithAggregatesFilter<"User">
    is_invited?: IntNullableWithAggregatesFilter<"User"> | number | null
    userName?: StringNullableWithAggregatesFilter<"User"> | string | null
    isBanned?: BoolWithAggregatesFilter<"User"> | boolean
    isAdmin?: BoolWithAggregatesFilter<"User"> | boolean
    isSubscribed?: BoolWithAggregatesFilter<"User"> | boolean
    countryOfResidenceISO?: EnumCountryCodeWithAggregatesFilter<"User"> | $Enums.CountryCode
    countryOfResidenceId?: IntNullableWithAggregatesFilter<"User"> | number | null
    dateOfBirth?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    emailVerified?: BoolWithAggregatesFilter<"User"> | boolean
    idVerified?: BoolWithAggregatesFilter<"User"> | boolean
    FavoriteExpertIds?: StringNullableListFilter<"User">
  }

  export type ExpertWhereInput = {
    AND?: ExpertWhereInput | ExpertWhereInput[]
    OR?: ExpertWhereInput[]
    NOT?: ExpertWhereInput | ExpertWhereInput[]
    id?: StringFilter<"Expert"> | string
    stripeAccountId?: IntNullableFilter<"Expert"> | number | null
    rate?: StringFilter<"Expert"> | string
    timezone?: StringFilter<"Expert"> | string
    user_id?: StringFilter<"Expert"> | string
    isAccepted?: BoolFilter<"Expert"> | boolean
    countryOfResidenceId?: IntNullableFilter<"Expert"> | number | null
    created_at?: DateTimeNullableFilter<"Expert"> | Date | string | null
    firstName?: StringFilter<"Expert"> | string
    lastName?: StringFilter<"Expert"> | string
    email?: StringNullableFilter<"Expert"> | string | null
    Appointment?: AppointmentListRelationFilter
    Availabilities?: AvailabilityListRelationFilter
    Chat?: ChatListRelationFilter
    ChatMessage?: ChatMessageListRelationFilter
    ClientReview?: ClientReviewListRelationFilter
    User?: XOR<UserRelationFilter, UserWhereInput>
    ExpertReview?: ExpertReviewListRelationFilter
    StripeAccount?: XOR<StripeAccountNullableRelationFilter, StripeAccountWhereInput> | null
  }

  export type ExpertOrderByWithRelationInput = {
    id?: SortOrder
    stripeAccountId?: SortOrderInput | SortOrder
    rate?: SortOrder
    timezone?: SortOrder
    user_id?: SortOrder
    isAccepted?: SortOrder
    countryOfResidenceId?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrderInput | SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    Availabilities?: AvailabilityOrderByRelationAggregateInput
    Chat?: ChatOrderByRelationAggregateInput
    ChatMessage?: ChatMessageOrderByRelationAggregateInput
    ClientReview?: ClientReviewOrderByRelationAggregateInput
    User?: UserOrderByWithRelationInput
    ExpertReview?: ExpertReviewOrderByRelationAggregateInput
    StripeAccount?: StripeAccountOrderByWithRelationInput
  }

  export type ExpertWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    user_id?: string
    AND?: ExpertWhereInput | ExpertWhereInput[]
    OR?: ExpertWhereInput[]
    NOT?: ExpertWhereInput | ExpertWhereInput[]
    stripeAccountId?: IntNullableFilter<"Expert"> | number | null
    rate?: StringFilter<"Expert"> | string
    timezone?: StringFilter<"Expert"> | string
    isAccepted?: BoolFilter<"Expert"> | boolean
    countryOfResidenceId?: IntNullableFilter<"Expert"> | number | null
    created_at?: DateTimeNullableFilter<"Expert"> | Date | string | null
    firstName?: StringFilter<"Expert"> | string
    lastName?: StringFilter<"Expert"> | string
    email?: StringNullableFilter<"Expert"> | string | null
    Appointment?: AppointmentListRelationFilter
    Availabilities?: AvailabilityListRelationFilter
    Chat?: ChatListRelationFilter
    ChatMessage?: ChatMessageListRelationFilter
    ClientReview?: ClientReviewListRelationFilter
    User?: XOR<UserRelationFilter, UserWhereInput>
    ExpertReview?: ExpertReviewListRelationFilter
    StripeAccount?: XOR<StripeAccountNullableRelationFilter, StripeAccountWhereInput> | null
  }, "id" | "id" | "user_id">

  export type ExpertOrderByWithAggregationInput = {
    id?: SortOrder
    stripeAccountId?: SortOrderInput | SortOrder
    rate?: SortOrder
    timezone?: SortOrder
    user_id?: SortOrder
    isAccepted?: SortOrder
    countryOfResidenceId?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrderInput | SortOrder
    _count?: ExpertCountOrderByAggregateInput
    _avg?: ExpertAvgOrderByAggregateInput
    _max?: ExpertMaxOrderByAggregateInput
    _min?: ExpertMinOrderByAggregateInput
    _sum?: ExpertSumOrderByAggregateInput
  }

  export type ExpertScalarWhereWithAggregatesInput = {
    AND?: ExpertScalarWhereWithAggregatesInput | ExpertScalarWhereWithAggregatesInput[]
    OR?: ExpertScalarWhereWithAggregatesInput[]
    NOT?: ExpertScalarWhereWithAggregatesInput | ExpertScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Expert"> | string
    stripeAccountId?: IntNullableWithAggregatesFilter<"Expert"> | number | null
    rate?: StringWithAggregatesFilter<"Expert"> | string
    timezone?: StringWithAggregatesFilter<"Expert"> | string
    user_id?: StringWithAggregatesFilter<"Expert"> | string
    isAccepted?: BoolWithAggregatesFilter<"Expert"> | boolean
    countryOfResidenceId?: IntNullableWithAggregatesFilter<"Expert"> | number | null
    created_at?: DateTimeNullableWithAggregatesFilter<"Expert"> | Date | string | null
    firstName?: StringWithAggregatesFilter<"Expert"> | string
    lastName?: StringWithAggregatesFilter<"Expert"> | string
    email?: StringNullableWithAggregatesFilter<"Expert"> | string | null
  }

  export type id_verificationWhereInput = {
    AND?: id_verificationWhereInput | id_verificationWhereInput[]
    OR?: id_verificationWhereInput[]
    NOT?: id_verificationWhereInput | id_verificationWhereInput[]
    id?: IntFilter<"id_verification"> | number
    status?: EnumStatusFilter<"id_verification"> | $Enums.Status
    userId?: StringFilter<"id_verification"> | string
    idImageUrlBack?: StringNullableFilter<"id_verification"> | string | null
    idImageUrlFront?: StringFilter<"id_verification"> | string
    createdAt?: DateTimeFilter<"id_verification"> | Date | string
    documentType?: EnumdocumentTypeFilter<"id_verification"> | $Enums.documentType
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type id_verificationOrderByWithRelationInput = {
    id?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    idImageUrlBack?: SortOrderInput | SortOrder
    idImageUrlFront?: SortOrder
    createdAt?: SortOrder
    documentType?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type id_verificationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: id_verificationWhereInput | id_verificationWhereInput[]
    OR?: id_verificationWhereInput[]
    NOT?: id_verificationWhereInput | id_verificationWhereInput[]
    status?: EnumStatusFilter<"id_verification"> | $Enums.Status
    userId?: StringFilter<"id_verification"> | string
    idImageUrlBack?: StringNullableFilter<"id_verification"> | string | null
    idImageUrlFront?: StringFilter<"id_verification"> | string
    createdAt?: DateTimeFilter<"id_verification"> | Date | string
    documentType?: EnumdocumentTypeFilter<"id_verification"> | $Enums.documentType
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type id_verificationOrderByWithAggregationInput = {
    id?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    idImageUrlBack?: SortOrderInput | SortOrder
    idImageUrlFront?: SortOrder
    createdAt?: SortOrder
    documentType?: SortOrder
    _count?: id_verificationCountOrderByAggregateInput
    _avg?: id_verificationAvgOrderByAggregateInput
    _max?: id_verificationMaxOrderByAggregateInput
    _min?: id_verificationMinOrderByAggregateInput
    _sum?: id_verificationSumOrderByAggregateInput
  }

  export type id_verificationScalarWhereWithAggregatesInput = {
    AND?: id_verificationScalarWhereWithAggregatesInput | id_verificationScalarWhereWithAggregatesInput[]
    OR?: id_verificationScalarWhereWithAggregatesInput[]
    NOT?: id_verificationScalarWhereWithAggregatesInput | id_verificationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"id_verification"> | number
    status?: EnumStatusWithAggregatesFilter<"id_verification"> | $Enums.Status
    userId?: StringWithAggregatesFilter<"id_verification"> | string
    idImageUrlBack?: StringNullableWithAggregatesFilter<"id_verification"> | string | null
    idImageUrlFront?: StringWithAggregatesFilter<"id_verification"> | string
    createdAt?: DateTimeWithAggregatesFilter<"id_verification"> | Date | string
    documentType?: EnumdocumentTypeWithAggregatesFilter<"id_verification"> | $Enums.documentType
  }

  export type email_verification_tokenWhereInput = {
    AND?: email_verification_tokenWhereInput | email_verification_tokenWhereInput[]
    OR?: email_verification_tokenWhereInput[]
    NOT?: email_verification_tokenWhereInput | email_verification_tokenWhereInput[]
    id?: StringFilter<"email_verification_token"> | string
    expires?: BigIntFilter<"email_verification_token"> | bigint | number
    userId?: StringFilter<"email_verification_token"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type email_verification_tokenOrderByWithRelationInput = {
    id?: SortOrder
    expires?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type email_verification_tokenWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: email_verification_tokenWhereInput | email_verification_tokenWhereInput[]
    OR?: email_verification_tokenWhereInput[]
    NOT?: email_verification_tokenWhereInput | email_verification_tokenWhereInput[]
    expires?: BigIntFilter<"email_verification_token"> | bigint | number
    userId?: StringFilter<"email_verification_token"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type email_verification_tokenOrderByWithAggregationInput = {
    id?: SortOrder
    expires?: SortOrder
    userId?: SortOrder
    _count?: email_verification_tokenCountOrderByAggregateInput
    _avg?: email_verification_tokenAvgOrderByAggregateInput
    _max?: email_verification_tokenMaxOrderByAggregateInput
    _min?: email_verification_tokenMinOrderByAggregateInput
    _sum?: email_verification_tokenSumOrderByAggregateInput
  }

  export type email_verification_tokenScalarWhereWithAggregatesInput = {
    AND?: email_verification_tokenScalarWhereWithAggregatesInput | email_verification_tokenScalarWhereWithAggregatesInput[]
    OR?: email_verification_tokenScalarWhereWithAggregatesInput[]
    NOT?: email_verification_tokenScalarWhereWithAggregatesInput | email_verification_tokenScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"email_verification_token"> | string
    expires?: BigIntWithAggregatesFilter<"email_verification_token"> | bigint | number
    userId?: StringWithAggregatesFilter<"email_verification_token"> | string
  }

  export type QuestionWhereInput = {
    AND?: QuestionWhereInput | QuestionWhereInput[]
    OR?: QuestionWhereInput[]
    NOT?: QuestionWhereInput | QuestionWhereInput[]
    id?: IntFilter<"Question"> | number
    content?: StringFilter<"Question"> | string
    userId?: StringFilter<"Question"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type QuestionOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type QuestionWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: QuestionWhereInput | QuestionWhereInput[]
    OR?: QuestionWhereInput[]
    NOT?: QuestionWhereInput | QuestionWhereInput[]
    content?: StringFilter<"Question"> | string
    userId?: StringFilter<"Question"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type QuestionOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    _count?: QuestionCountOrderByAggregateInput
    _avg?: QuestionAvgOrderByAggregateInput
    _max?: QuestionMaxOrderByAggregateInput
    _min?: QuestionMinOrderByAggregateInput
    _sum?: QuestionSumOrderByAggregateInput
  }

  export type QuestionScalarWhereWithAggregatesInput = {
    AND?: QuestionScalarWhereWithAggregatesInput | QuestionScalarWhereWithAggregatesInput[]
    OR?: QuestionScalarWhereWithAggregatesInput[]
    NOT?: QuestionScalarWhereWithAggregatesInput | QuestionScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Question"> | number
    content?: StringWithAggregatesFilter<"Question"> | string
    userId?: StringWithAggregatesFilter<"Question"> | string
  }

  export type ReplyWhereInput = {
    AND?: ReplyWhereInput | ReplyWhereInput[]
    OR?: ReplyWhereInput[]
    NOT?: ReplyWhereInput | ReplyWhereInput[]
    id?: IntFilter<"Reply"> | number
    content?: StringFilter<"Reply"> | string
    appointmentKey?: StringFilter<"Reply"> | string
    questionContent?: StringFilter<"Reply"> | string
    userId?: StringFilter<"Reply"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ReplyOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    appointmentKey?: SortOrder
    questionContent?: SortOrder
    userId?: SortOrder
    appointment?: AppointmentOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type ReplyWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ReplyWhereInput | ReplyWhereInput[]
    OR?: ReplyWhereInput[]
    NOT?: ReplyWhereInput | ReplyWhereInput[]
    content?: StringFilter<"Reply"> | string
    appointmentKey?: StringFilter<"Reply"> | string
    questionContent?: StringFilter<"Reply"> | string
    userId?: StringFilter<"Reply"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type ReplyOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    appointmentKey?: SortOrder
    questionContent?: SortOrder
    userId?: SortOrder
    _count?: ReplyCountOrderByAggregateInput
    _avg?: ReplyAvgOrderByAggregateInput
    _max?: ReplyMaxOrderByAggregateInput
    _min?: ReplyMinOrderByAggregateInput
    _sum?: ReplySumOrderByAggregateInput
  }

  export type ReplyScalarWhereWithAggregatesInput = {
    AND?: ReplyScalarWhereWithAggregatesInput | ReplyScalarWhereWithAggregatesInput[]
    OR?: ReplyScalarWhereWithAggregatesInput[]
    NOT?: ReplyScalarWhereWithAggregatesInput | ReplyScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Reply"> | number
    content?: StringWithAggregatesFilter<"Reply"> | string
    appointmentKey?: StringWithAggregatesFilter<"Reply"> | string
    questionContent?: StringWithAggregatesFilter<"Reply"> | string
    userId?: StringWithAggregatesFilter<"Reply"> | string
  }

  export type StripeAccountWhereInput = {
    AND?: StripeAccountWhereInput | StripeAccountWhereInput[]
    OR?: StripeAccountWhereInput[]
    NOT?: StripeAccountWhereInput | StripeAccountWhereInput[]
    id?: IntFilter<"StripeAccount"> | number
    stripeData?: JsonFilter<"StripeAccount">
    expertId?: StringFilter<"StripeAccount"> | string
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }

  export type StripeAccountOrderByWithRelationInput = {
    id?: SortOrder
    stripeData?: SortOrder
    expertId?: SortOrder
    expert?: ExpertOrderByWithRelationInput
  }

  export type StripeAccountWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    expertId?: string
    AND?: StripeAccountWhereInput | StripeAccountWhereInput[]
    OR?: StripeAccountWhereInput[]
    NOT?: StripeAccountWhereInput | StripeAccountWhereInput[]
    stripeData?: JsonFilter<"StripeAccount">
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }, "id" | "expertId">

  export type StripeAccountOrderByWithAggregationInput = {
    id?: SortOrder
    stripeData?: SortOrder
    expertId?: SortOrder
    _count?: StripeAccountCountOrderByAggregateInput
    _avg?: StripeAccountAvgOrderByAggregateInput
    _max?: StripeAccountMaxOrderByAggregateInput
    _min?: StripeAccountMinOrderByAggregateInput
    _sum?: StripeAccountSumOrderByAggregateInput
  }

  export type StripeAccountScalarWhereWithAggregatesInput = {
    AND?: StripeAccountScalarWhereWithAggregatesInput | StripeAccountScalarWhereWithAggregatesInput[]
    OR?: StripeAccountScalarWhereWithAggregatesInput[]
    NOT?: StripeAccountScalarWhereWithAggregatesInput | StripeAccountScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"StripeAccount"> | number
    stripeData?: JsonWithAggregatesFilter<"StripeAccount">
    expertId?: StringWithAggregatesFilter<"StripeAccount"> | string
  }

  export type KeyWhereInput = {
    AND?: KeyWhereInput | KeyWhereInput[]
    OR?: KeyWhereInput[]
    NOT?: KeyWhereInput | KeyWhereInput[]
    id?: StringFilter<"Key"> | string
    hashed_password?: StringNullableFilter<"Key"> | string | null
    user_id?: StringFilter<"Key"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type KeyOrderByWithRelationInput = {
    id?: SortOrder
    hashed_password?: SortOrderInput | SortOrder
    user_id?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type KeyWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: KeyWhereInput | KeyWhereInput[]
    OR?: KeyWhereInput[]
    NOT?: KeyWhereInput | KeyWhereInput[]
    hashed_password?: StringNullableFilter<"Key"> | string | null
    user_id?: StringFilter<"Key"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type KeyOrderByWithAggregationInput = {
    id?: SortOrder
    hashed_password?: SortOrderInput | SortOrder
    user_id?: SortOrder
    _count?: KeyCountOrderByAggregateInput
    _max?: KeyMaxOrderByAggregateInput
    _min?: KeyMinOrderByAggregateInput
  }

  export type KeyScalarWhereWithAggregatesInput = {
    AND?: KeyScalarWhereWithAggregatesInput | KeyScalarWhereWithAggregatesInput[]
    OR?: KeyScalarWhereWithAggregatesInput[]
    NOT?: KeyScalarWhereWithAggregatesInput | KeyScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Key"> | string
    hashed_password?: StringNullableWithAggregatesFilter<"Key"> | string | null
    user_id?: StringWithAggregatesFilter<"Key"> | string
  }

  export type ExperienceWhereInput = {
    AND?: ExperienceWhereInput | ExperienceWhereInput[]
    OR?: ExperienceWhereInput[]
    NOT?: ExperienceWhereInput | ExperienceWhereInput[]
    id?: IntFilter<"Experience"> | number
    companyName?: StringFilter<"Experience"> | string
    role?: StringFilter<"Experience"> | string
    isCurrent?: BoolFilter<"Experience"> | boolean
    duration?: StringFilter<"Experience"> | string
    description?: StringFilter<"Experience"> | string
    userId?: StringFilter<"Experience"> | string
    endDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
    startDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ExperienceOrderByWithRelationInput = {
    id?: SortOrder
    companyName?: SortOrder
    role?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    description?: SortOrder
    userId?: SortOrder
    endDate?: SortOrderInput | SortOrder
    startDate?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type ExperienceWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ExperienceWhereInput | ExperienceWhereInput[]
    OR?: ExperienceWhereInput[]
    NOT?: ExperienceWhereInput | ExperienceWhereInput[]
    companyName?: StringFilter<"Experience"> | string
    role?: StringFilter<"Experience"> | string
    isCurrent?: BoolFilter<"Experience"> | boolean
    duration?: StringFilter<"Experience"> | string
    description?: StringFilter<"Experience"> | string
    userId?: StringFilter<"Experience"> | string
    endDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
    startDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type ExperienceOrderByWithAggregationInput = {
    id?: SortOrder
    companyName?: SortOrder
    role?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    description?: SortOrder
    userId?: SortOrder
    endDate?: SortOrderInput | SortOrder
    startDate?: SortOrderInput | SortOrder
    _count?: ExperienceCountOrderByAggregateInput
    _avg?: ExperienceAvgOrderByAggregateInput
    _max?: ExperienceMaxOrderByAggregateInput
    _min?: ExperienceMinOrderByAggregateInput
    _sum?: ExperienceSumOrderByAggregateInput
  }

  export type ExperienceScalarWhereWithAggregatesInput = {
    AND?: ExperienceScalarWhereWithAggregatesInput | ExperienceScalarWhereWithAggregatesInput[]
    OR?: ExperienceScalarWhereWithAggregatesInput[]
    NOT?: ExperienceScalarWhereWithAggregatesInput | ExperienceScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Experience"> | number
    companyName?: StringWithAggregatesFilter<"Experience"> | string
    role?: StringWithAggregatesFilter<"Experience"> | string
    isCurrent?: BoolWithAggregatesFilter<"Experience"> | boolean
    duration?: StringWithAggregatesFilter<"Experience"> | string
    description?: StringWithAggregatesFilter<"Experience"> | string
    userId?: StringWithAggregatesFilter<"Experience"> | string
    endDate?: DateTimeNullableWithAggregatesFilter<"Experience"> | Date | string | null
    startDate?: DateTimeNullableWithAggregatesFilter<"Experience"> | Date | string | null
  }

  export type EducationWhereInput = {
    AND?: EducationWhereInput | EducationWhereInput[]
    OR?: EducationWhereInput[]
    NOT?: EducationWhereInput | EducationWhereInput[]
    id?: IntFilter<"Education"> | number
    institutionName?: StringFilter<"Education"> | string
    diplomaTitle?: StringFilter<"Education"> | string
    fieldOfStudy?: StringFilter<"Education"> | string
    isCurrent?: BoolFilter<"Education"> | boolean
    duration?: StringFilter<"Education"> | string
    userId?: StringFilter<"Education"> | string
    startDate?: DateTimeNullableFilter<"Education"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Education"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type EducationOrderByWithRelationInput = {
    id?: SortOrder
    institutionName?: SortOrder
    diplomaTitle?: SortOrder
    fieldOfStudy?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrderInput | SortOrder
    endDate?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type EducationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: EducationWhereInput | EducationWhereInput[]
    OR?: EducationWhereInput[]
    NOT?: EducationWhereInput | EducationWhereInput[]
    institutionName?: StringFilter<"Education"> | string
    diplomaTitle?: StringFilter<"Education"> | string
    fieldOfStudy?: StringFilter<"Education"> | string
    isCurrent?: BoolFilter<"Education"> | boolean
    duration?: StringFilter<"Education"> | string
    userId?: StringFilter<"Education"> | string
    startDate?: DateTimeNullableFilter<"Education"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Education"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type EducationOrderByWithAggregationInput = {
    id?: SortOrder
    institutionName?: SortOrder
    diplomaTitle?: SortOrder
    fieldOfStudy?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrderInput | SortOrder
    endDate?: SortOrderInput | SortOrder
    _count?: EducationCountOrderByAggregateInput
    _avg?: EducationAvgOrderByAggregateInput
    _max?: EducationMaxOrderByAggregateInput
    _min?: EducationMinOrderByAggregateInput
    _sum?: EducationSumOrderByAggregateInput
  }

  export type EducationScalarWhereWithAggregatesInput = {
    AND?: EducationScalarWhereWithAggregatesInput | EducationScalarWhereWithAggregatesInput[]
    OR?: EducationScalarWhereWithAggregatesInput[]
    NOT?: EducationScalarWhereWithAggregatesInput | EducationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Education"> | number
    institutionName?: StringWithAggregatesFilter<"Education"> | string
    diplomaTitle?: StringWithAggregatesFilter<"Education"> | string
    fieldOfStudy?: StringWithAggregatesFilter<"Education"> | string
    isCurrent?: BoolWithAggregatesFilter<"Education"> | boolean
    duration?: StringWithAggregatesFilter<"Education"> | string
    userId?: StringWithAggregatesFilter<"Education"> | string
    startDate?: DateTimeNullableWithAggregatesFilter<"Education"> | Date | string | null
    endDate?: DateTimeNullableWithAggregatesFilter<"Education"> | Date | string | null
  }

  export type ExpertiseWhereInput = {
    AND?: ExpertiseWhereInput | ExpertiseWhereInput[]
    OR?: ExpertiseWhereInput[]
    NOT?: ExpertiseWhereInput | ExpertiseWhereInput[]
    id?: IntFilter<"Expertise"> | number
    field?: StringFilter<"Expertise"> | string
    isCurrent?: BoolFilter<"Expertise"> | boolean
    description?: StringFilter<"Expertise"> | string
    duration?: StringFilter<"Expertise"> | string
    userId?: StringFilter<"Expertise"> | string
    startDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ExpertiseOrderByWithRelationInput = {
    id?: SortOrder
    field?: SortOrder
    isCurrent?: SortOrder
    description?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrderInput | SortOrder
    endDate?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type ExpertiseWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ExpertiseWhereInput | ExpertiseWhereInput[]
    OR?: ExpertiseWhereInput[]
    NOT?: ExpertiseWhereInput | ExpertiseWhereInput[]
    field?: StringFilter<"Expertise"> | string
    isCurrent?: BoolFilter<"Expertise"> | boolean
    description?: StringFilter<"Expertise"> | string
    duration?: StringFilter<"Expertise"> | string
    userId?: StringFilter<"Expertise"> | string
    startDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type ExpertiseOrderByWithAggregationInput = {
    id?: SortOrder
    field?: SortOrder
    isCurrent?: SortOrder
    description?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrderInput | SortOrder
    endDate?: SortOrderInput | SortOrder
    _count?: ExpertiseCountOrderByAggregateInput
    _avg?: ExpertiseAvgOrderByAggregateInput
    _max?: ExpertiseMaxOrderByAggregateInput
    _min?: ExpertiseMinOrderByAggregateInput
    _sum?: ExpertiseSumOrderByAggregateInput
  }

  export type ExpertiseScalarWhereWithAggregatesInput = {
    AND?: ExpertiseScalarWhereWithAggregatesInput | ExpertiseScalarWhereWithAggregatesInput[]
    OR?: ExpertiseScalarWhereWithAggregatesInput[]
    NOT?: ExpertiseScalarWhereWithAggregatesInput | ExpertiseScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Expertise"> | number
    field?: StringWithAggregatesFilter<"Expertise"> | string
    isCurrent?: BoolWithAggregatesFilter<"Expertise"> | boolean
    description?: StringWithAggregatesFilter<"Expertise"> | string
    duration?: StringWithAggregatesFilter<"Expertise"> | string
    userId?: StringWithAggregatesFilter<"Expertise"> | string
    startDate?: DateTimeNullableWithAggregatesFilter<"Expertise"> | Date | string | null
    endDate?: DateTimeNullableWithAggregatesFilter<"Expertise"> | Date | string | null
  }

  export type LanguageWhereInput = {
    AND?: LanguageWhereInput | LanguageWhereInput[]
    OR?: LanguageWhereInput[]
    NOT?: LanguageWhereInput | LanguageWhereInput[]
    id?: IntFilter<"Language"> | number
    name?: StringFilter<"Language"> | string
    userId?: StringFilter<"Language"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type LanguageOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type LanguageWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: LanguageWhereInput | LanguageWhereInput[]
    OR?: LanguageWhereInput[]
    NOT?: LanguageWhereInput | LanguageWhereInput[]
    name?: StringFilter<"Language"> | string
    userId?: StringFilter<"Language"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type LanguageOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    _count?: LanguageCountOrderByAggregateInput
    _avg?: LanguageAvgOrderByAggregateInput
    _max?: LanguageMaxOrderByAggregateInput
    _min?: LanguageMinOrderByAggregateInput
    _sum?: LanguageSumOrderByAggregateInput
  }

  export type LanguageScalarWhereWithAggregatesInput = {
    AND?: LanguageScalarWhereWithAggregatesInput | LanguageScalarWhereWithAggregatesInput[]
    OR?: LanguageScalarWhereWithAggregatesInput[]
    NOT?: LanguageScalarWhereWithAggregatesInput | LanguageScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Language"> | number
    name?: StringWithAggregatesFilter<"Language"> | string
    userId?: StringWithAggregatesFilter<"Language"> | string
  }

  export type AppointmentWhereInput = {
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    id?: IntFilter<"Appointment"> | number
    clientId?: StringFilter<"Appointment"> | string
    clientEmail?: StringFilter<"Appointment"> | string
    expertId?: StringFilter<"Appointment"> | string
    clientName?: StringFilter<"Appointment"> | string
    expertName?: StringFilter<"Appointment"> | string
    isAcceptedByExpert?: StringFilter<"Appointment"> | string
    price?: StringFilter<"Appointment"> | string
    timezone?: StringFilter<"Appointment"> | string
    date?: IntFilter<"Appointment"> | number
    dayName?: StringFilter<"Appointment"> | string
    time?: StringFilter<"Appointment"> | string
    text?: StringNullableFilter<"Appointment"> | string | null
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    videoRoomId?: StringFilter<"Appointment"> | string
    appointmentKey?: StringFilter<"Appointment"> | string
    paymentStatus?: StringFilter<"Appointment"> | string
    paymentIntentId?: StringFilter<"Appointment"> | string
    sessionId?: StringFilter<"Appointment"> | string
    authorizedDate?: StringFilter<"Appointment"> | string
    appointementKeyInExpertTimeZone?: StringFilter<"Appointment"> | string
    appointementKeyInClientTimeZone?: StringFilter<"Appointment"> | string
    bookedAppointments?: JsonNullableFilter<"Appointment">
    status?: StringFilter<"Appointment"> | string
    reason?: StringNullableFilter<"Appointment"> | string | null
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    receivedClientReviews?: XOR<ClientReviewNullableRelationFilter, ClientReviewWhereInput> | null
    writtenExpertReviews?: XOR<ExpertReviewNullableRelationFilter, ExpertReviewWhereInput> | null
    reply?: ReplyListRelationFilter
  }

  export type AppointmentOrderByWithRelationInput = {
    id?: SortOrder
    clientId?: SortOrder
    clientEmail?: SortOrder
    expertId?: SortOrder
    clientName?: SortOrder
    expertName?: SortOrder
    isAcceptedByExpert?: SortOrder
    price?: SortOrder
    timezone?: SortOrder
    date?: SortOrder
    dayName?: SortOrder
    time?: SortOrder
    text?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    paymentStatus?: SortOrder
    paymentIntentId?: SortOrder
    sessionId?: SortOrder
    authorizedDate?: SortOrder
    appointementKeyInExpertTimeZone?: SortOrder
    appointementKeyInClientTimeZone?: SortOrder
    bookedAppointments?: SortOrderInput | SortOrder
    status?: SortOrder
    reason?: SortOrderInput | SortOrder
    client?: UserOrderByWithRelationInput
    expert?: ExpertOrderByWithRelationInput
    receivedClientReviews?: ClientReviewOrderByWithRelationInput
    writtenExpertReviews?: ExpertReviewOrderByWithRelationInput
    reply?: ReplyOrderByRelationAggregateInput
  }

  export type AppointmentWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    videoRoomId?: string
    appointmentKey?: string
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    clientId?: StringFilter<"Appointment"> | string
    clientEmail?: StringFilter<"Appointment"> | string
    expertId?: StringFilter<"Appointment"> | string
    clientName?: StringFilter<"Appointment"> | string
    expertName?: StringFilter<"Appointment"> | string
    isAcceptedByExpert?: StringFilter<"Appointment"> | string
    price?: StringFilter<"Appointment"> | string
    timezone?: StringFilter<"Appointment"> | string
    date?: IntFilter<"Appointment"> | number
    dayName?: StringFilter<"Appointment"> | string
    time?: StringFilter<"Appointment"> | string
    text?: StringNullableFilter<"Appointment"> | string | null
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    paymentStatus?: StringFilter<"Appointment"> | string
    paymentIntentId?: StringFilter<"Appointment"> | string
    sessionId?: StringFilter<"Appointment"> | string
    authorizedDate?: StringFilter<"Appointment"> | string
    appointementKeyInExpertTimeZone?: StringFilter<"Appointment"> | string
    appointementKeyInClientTimeZone?: StringFilter<"Appointment"> | string
    bookedAppointments?: JsonNullableFilter<"Appointment">
    status?: StringFilter<"Appointment"> | string
    reason?: StringNullableFilter<"Appointment"> | string | null
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    receivedClientReviews?: XOR<ClientReviewNullableRelationFilter, ClientReviewWhereInput> | null
    writtenExpertReviews?: XOR<ExpertReviewNullableRelationFilter, ExpertReviewWhereInput> | null
    reply?: ReplyListRelationFilter
  }, "id" | "videoRoomId" | "appointmentKey">

  export type AppointmentOrderByWithAggregationInput = {
    id?: SortOrder
    clientId?: SortOrder
    clientEmail?: SortOrder
    expertId?: SortOrder
    clientName?: SortOrder
    expertName?: SortOrder
    isAcceptedByExpert?: SortOrder
    price?: SortOrder
    timezone?: SortOrder
    date?: SortOrder
    dayName?: SortOrder
    time?: SortOrder
    text?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    paymentStatus?: SortOrder
    paymentIntentId?: SortOrder
    sessionId?: SortOrder
    authorizedDate?: SortOrder
    appointementKeyInExpertTimeZone?: SortOrder
    appointementKeyInClientTimeZone?: SortOrder
    bookedAppointments?: SortOrderInput | SortOrder
    status?: SortOrder
    reason?: SortOrderInput | SortOrder
    _count?: AppointmentCountOrderByAggregateInput
    _avg?: AppointmentAvgOrderByAggregateInput
    _max?: AppointmentMaxOrderByAggregateInput
    _min?: AppointmentMinOrderByAggregateInput
    _sum?: AppointmentSumOrderByAggregateInput
  }

  export type AppointmentScalarWhereWithAggregatesInput = {
    AND?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    OR?: AppointmentScalarWhereWithAggregatesInput[]
    NOT?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Appointment"> | number
    clientId?: StringWithAggregatesFilter<"Appointment"> | string
    clientEmail?: StringWithAggregatesFilter<"Appointment"> | string
    expertId?: StringWithAggregatesFilter<"Appointment"> | string
    clientName?: StringWithAggregatesFilter<"Appointment"> | string
    expertName?: StringWithAggregatesFilter<"Appointment"> | string
    isAcceptedByExpert?: StringWithAggregatesFilter<"Appointment"> | string
    price?: StringWithAggregatesFilter<"Appointment"> | string
    timezone?: StringWithAggregatesFilter<"Appointment"> | string
    date?: IntWithAggregatesFilter<"Appointment"> | number
    dayName?: StringWithAggregatesFilter<"Appointment"> | string
    time?: StringWithAggregatesFilter<"Appointment"> | string
    text?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    videoRoomId?: StringWithAggregatesFilter<"Appointment"> | string
    appointmentKey?: StringWithAggregatesFilter<"Appointment"> | string
    paymentStatus?: StringWithAggregatesFilter<"Appointment"> | string
    paymentIntentId?: StringWithAggregatesFilter<"Appointment"> | string
    sessionId?: StringWithAggregatesFilter<"Appointment"> | string
    authorizedDate?: StringWithAggregatesFilter<"Appointment"> | string
    appointementKeyInExpertTimeZone?: StringWithAggregatesFilter<"Appointment"> | string
    appointementKeyInClientTimeZone?: StringWithAggregatesFilter<"Appointment"> | string
    bookedAppointments?: JsonNullableWithAggregatesFilter<"Appointment">
    status?: StringWithAggregatesFilter<"Appointment"> | string
    reason?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
  }

  export type AvailabilityWhereInput = {
    AND?: AvailabilityWhereInput | AvailabilityWhereInput[]
    OR?: AvailabilityWhereInput[]
    NOT?: AvailabilityWhereInput | AvailabilityWhereInput[]
    id?: IntFilter<"Availability"> | number
    day?: StringFilter<"Availability"> | string
    timezone?: StringFilter<"Availability"> | string
    expertId?: StringFilter<"Availability"> | string
    userId?: StringNullableFilter<"Availability"> | string | null
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
    slots?: SlotListRelationFilter
  }

  export type AvailabilityOrderByWithRelationInput = {
    id?: SortOrder
    day?: SortOrder
    timezone?: SortOrder
    expertId?: SortOrder
    userId?: SortOrderInput | SortOrder
    expert?: ExpertOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    slots?: SlotOrderByRelationAggregateInput
  }

  export type AvailabilityWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AvailabilityWhereInput | AvailabilityWhereInput[]
    OR?: AvailabilityWhereInput[]
    NOT?: AvailabilityWhereInput | AvailabilityWhereInput[]
    day?: StringFilter<"Availability"> | string
    timezone?: StringFilter<"Availability"> | string
    expertId?: StringFilter<"Availability"> | string
    userId?: StringNullableFilter<"Availability"> | string | null
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
    slots?: SlotListRelationFilter
  }, "id">

  export type AvailabilityOrderByWithAggregationInput = {
    id?: SortOrder
    day?: SortOrder
    timezone?: SortOrder
    expertId?: SortOrder
    userId?: SortOrderInput | SortOrder
    _count?: AvailabilityCountOrderByAggregateInput
    _avg?: AvailabilityAvgOrderByAggregateInput
    _max?: AvailabilityMaxOrderByAggregateInput
    _min?: AvailabilityMinOrderByAggregateInput
    _sum?: AvailabilitySumOrderByAggregateInput
  }

  export type AvailabilityScalarWhereWithAggregatesInput = {
    AND?: AvailabilityScalarWhereWithAggregatesInput | AvailabilityScalarWhereWithAggregatesInput[]
    OR?: AvailabilityScalarWhereWithAggregatesInput[]
    NOT?: AvailabilityScalarWhereWithAggregatesInput | AvailabilityScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Availability"> | number
    day?: StringWithAggregatesFilter<"Availability"> | string
    timezone?: StringWithAggregatesFilter<"Availability"> | string
    expertId?: StringWithAggregatesFilter<"Availability"> | string
    userId?: StringNullableWithAggregatesFilter<"Availability"> | string | null
  }

  export type SlotWhereInput = {
    AND?: SlotWhereInput | SlotWhereInput[]
    OR?: SlotWhereInput[]
    NOT?: SlotWhereInput | SlotWhereInput[]
    id?: StringFilter<"Slot"> | string
    start?: StringFilter<"Slot"> | string
    end?: StringFilter<"Slot"> | string
    recurring?: BoolFilter<"Slot"> | boolean
    availabilityId?: IntFilter<"Slot"> | number
    hide?: BoolFilter<"Slot"> | boolean
    isSplit?: BoolFilter<"Slot"> | boolean
    originalId?: StringFilter<"Slot"> | string
    exceptions?: ExceptionListRelationFilter
    Availability?: XOR<AvailabilityRelationFilter, AvailabilityWhereInput>
  }

  export type SlotOrderByWithRelationInput = {
    id?: SortOrder
    start?: SortOrder
    end?: SortOrder
    recurring?: SortOrder
    availabilityId?: SortOrder
    hide?: SortOrder
    isSplit?: SortOrder
    originalId?: SortOrder
    exceptions?: ExceptionOrderByRelationAggregateInput
    Availability?: AvailabilityOrderByWithRelationInput
  }

  export type SlotWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SlotWhereInput | SlotWhereInput[]
    OR?: SlotWhereInput[]
    NOT?: SlotWhereInput | SlotWhereInput[]
    start?: StringFilter<"Slot"> | string
    end?: StringFilter<"Slot"> | string
    recurring?: BoolFilter<"Slot"> | boolean
    availabilityId?: IntFilter<"Slot"> | number
    hide?: BoolFilter<"Slot"> | boolean
    isSplit?: BoolFilter<"Slot"> | boolean
    originalId?: StringFilter<"Slot"> | string
    exceptions?: ExceptionListRelationFilter
    Availability?: XOR<AvailabilityRelationFilter, AvailabilityWhereInput>
  }, "id">

  export type SlotOrderByWithAggregationInput = {
    id?: SortOrder
    start?: SortOrder
    end?: SortOrder
    recurring?: SortOrder
    availabilityId?: SortOrder
    hide?: SortOrder
    isSplit?: SortOrder
    originalId?: SortOrder
    _count?: SlotCountOrderByAggregateInput
    _avg?: SlotAvgOrderByAggregateInput
    _max?: SlotMaxOrderByAggregateInput
    _min?: SlotMinOrderByAggregateInput
    _sum?: SlotSumOrderByAggregateInput
  }

  export type SlotScalarWhereWithAggregatesInput = {
    AND?: SlotScalarWhereWithAggregatesInput | SlotScalarWhereWithAggregatesInput[]
    OR?: SlotScalarWhereWithAggregatesInput[]
    NOT?: SlotScalarWhereWithAggregatesInput | SlotScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Slot"> | string
    start?: StringWithAggregatesFilter<"Slot"> | string
    end?: StringWithAggregatesFilter<"Slot"> | string
    recurring?: BoolWithAggregatesFilter<"Slot"> | boolean
    availabilityId?: IntWithAggregatesFilter<"Slot"> | number
    hide?: BoolWithAggregatesFilter<"Slot"> | boolean
    isSplit?: BoolWithAggregatesFilter<"Slot"> | boolean
    originalId?: StringWithAggregatesFilter<"Slot"> | string
  }

  export type ExceptionWhereInput = {
    AND?: ExceptionWhereInput | ExceptionWhereInput[]
    OR?: ExceptionWhereInput[]
    NOT?: ExceptionWhereInput | ExceptionWhereInput[]
    id?: IntFilter<"Exception"> | number
    date?: StringFilter<"Exception"> | string
    slotId?: StringFilter<"Exception"> | string
    Slot?: XOR<SlotRelationFilter, SlotWhereInput>
  }

  export type ExceptionOrderByWithRelationInput = {
    id?: SortOrder
    date?: SortOrder
    slotId?: SortOrder
    Slot?: SlotOrderByWithRelationInput
  }

  export type ExceptionWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ExceptionWhereInput | ExceptionWhereInput[]
    OR?: ExceptionWhereInput[]
    NOT?: ExceptionWhereInput | ExceptionWhereInput[]
    date?: StringFilter<"Exception"> | string
    slotId?: StringFilter<"Exception"> | string
    Slot?: XOR<SlotRelationFilter, SlotWhereInput>
  }, "id">

  export type ExceptionOrderByWithAggregationInput = {
    id?: SortOrder
    date?: SortOrder
    slotId?: SortOrder
    _count?: ExceptionCountOrderByAggregateInput
    _avg?: ExceptionAvgOrderByAggregateInput
    _max?: ExceptionMaxOrderByAggregateInput
    _min?: ExceptionMinOrderByAggregateInput
    _sum?: ExceptionSumOrderByAggregateInput
  }

  export type ExceptionScalarWhereWithAggregatesInput = {
    AND?: ExceptionScalarWhereWithAggregatesInput | ExceptionScalarWhereWithAggregatesInput[]
    OR?: ExceptionScalarWhereWithAggregatesInput[]
    NOT?: ExceptionScalarWhereWithAggregatesInput | ExceptionScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Exception"> | number
    date?: StringWithAggregatesFilter<"Exception"> | string
    slotId?: StringWithAggregatesFilter<"Exception"> | string
  }

  export type ChatWhereInput = {
    AND?: ChatWhereInput | ChatWhereInput[]
    OR?: ChatWhereInput[]
    NOT?: ChatWhereInput | ChatWhereInput[]
    id?: StringFilter<"Chat"> | string
    createdAt?: DateTimeFilter<"Chat"> | Date | string
    updatedAt?: DateTimeFilter<"Chat"> | Date | string
    clientId?: StringFilter<"Chat"> | string
    expertId?: StringFilter<"Chat"> | string
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    messages?: ChatMessageListRelationFilter
  }

  export type ChatOrderByWithRelationInput = {
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
    client?: UserOrderByWithRelationInput
    expert?: ExpertOrderByWithRelationInput
    messages?: ChatMessageOrderByRelationAggregateInput
  }

  export type ChatWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ChatWhereInput | ChatWhereInput[]
    OR?: ChatWhereInput[]
    NOT?: ChatWhereInput | ChatWhereInput[]
    createdAt?: DateTimeFilter<"Chat"> | Date | string
    updatedAt?: DateTimeFilter<"Chat"> | Date | string
    clientId?: StringFilter<"Chat"> | string
    expertId?: StringFilter<"Chat"> | string
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
    messages?: ChatMessageListRelationFilter
  }, "id" | "id">

  export type ChatOrderByWithAggregationInput = {
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
    _count?: ChatCountOrderByAggregateInput
    _max?: ChatMaxOrderByAggregateInput
    _min?: ChatMinOrderByAggregateInput
  }

  export type ChatScalarWhereWithAggregatesInput = {
    AND?: ChatScalarWhereWithAggregatesInput | ChatScalarWhereWithAggregatesInput[]
    OR?: ChatScalarWhereWithAggregatesInput[]
    NOT?: ChatScalarWhereWithAggregatesInput | ChatScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Chat"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Chat"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Chat"> | Date | string
    clientId?: StringWithAggregatesFilter<"Chat"> | string
    expertId?: StringWithAggregatesFilter<"Chat"> | string
  }

  export type ChatMessageWhereInput = {
    AND?: ChatMessageWhereInput | ChatMessageWhereInput[]
    OR?: ChatMessageWhereInput[]
    NOT?: ChatMessageWhereInput | ChatMessageWhereInput[]
    id?: IntFilter<"ChatMessage"> | number
    content?: StringFilter<"ChatMessage"> | string
    userId?: StringFilter<"ChatMessage"> | string
    fileName?: StringFilter<"ChatMessage"> | string
    type?: StringFilter<"ChatMessage"> | string
    fileType?: StringFilter<"ChatMessage"> | string
    fileUrl?: StringFilter<"ChatMessage"> | string
    createdAt?: DateTimeFilter<"ChatMessage"> | Date | string
    chatId?: StringFilter<"ChatMessage"> | string
    senderId?: StringFilter<"ChatMessage"> | string
    expertId?: StringNullableFilter<"ChatMessage"> | string | null
    chat?: XOR<ChatRelationFilter, ChatWhereInput>
    Expert?: XOR<ExpertNullableRelationFilter, ExpertWhereInput> | null
    sender?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ChatMessageOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    fileName?: SortOrder
    type?: SortOrder
    fileType?: SortOrder
    fileUrl?: SortOrder
    createdAt?: SortOrder
    chatId?: SortOrder
    senderId?: SortOrder
    expertId?: SortOrderInput | SortOrder
    chat?: ChatOrderByWithRelationInput
    Expert?: ExpertOrderByWithRelationInput
    sender?: UserOrderByWithRelationInput
  }

  export type ChatMessageWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChatMessageWhereInput | ChatMessageWhereInput[]
    OR?: ChatMessageWhereInput[]
    NOT?: ChatMessageWhereInput | ChatMessageWhereInput[]
    content?: StringFilter<"ChatMessage"> | string
    userId?: StringFilter<"ChatMessage"> | string
    fileName?: StringFilter<"ChatMessage"> | string
    type?: StringFilter<"ChatMessage"> | string
    fileType?: StringFilter<"ChatMessage"> | string
    fileUrl?: StringFilter<"ChatMessage"> | string
    createdAt?: DateTimeFilter<"ChatMessage"> | Date | string
    chatId?: StringFilter<"ChatMessage"> | string
    senderId?: StringFilter<"ChatMessage"> | string
    expertId?: StringNullableFilter<"ChatMessage"> | string | null
    chat?: XOR<ChatRelationFilter, ChatWhereInput>
    Expert?: XOR<ExpertNullableRelationFilter, ExpertWhereInput> | null
    sender?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type ChatMessageOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    fileName?: SortOrder
    type?: SortOrder
    fileType?: SortOrder
    fileUrl?: SortOrder
    createdAt?: SortOrder
    chatId?: SortOrder
    senderId?: SortOrder
    expertId?: SortOrderInput | SortOrder
    _count?: ChatMessageCountOrderByAggregateInput
    _avg?: ChatMessageAvgOrderByAggregateInput
    _max?: ChatMessageMaxOrderByAggregateInput
    _min?: ChatMessageMinOrderByAggregateInput
    _sum?: ChatMessageSumOrderByAggregateInput
  }

  export type ChatMessageScalarWhereWithAggregatesInput = {
    AND?: ChatMessageScalarWhereWithAggregatesInput | ChatMessageScalarWhereWithAggregatesInput[]
    OR?: ChatMessageScalarWhereWithAggregatesInput[]
    NOT?: ChatMessageScalarWhereWithAggregatesInput | ChatMessageScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChatMessage"> | number
    content?: StringWithAggregatesFilter<"ChatMessage"> | string
    userId?: StringWithAggregatesFilter<"ChatMessage"> | string
    fileName?: StringWithAggregatesFilter<"ChatMessage"> | string
    type?: StringWithAggregatesFilter<"ChatMessage"> | string
    fileType?: StringWithAggregatesFilter<"ChatMessage"> | string
    fileUrl?: StringWithAggregatesFilter<"ChatMessage"> | string
    createdAt?: DateTimeWithAggregatesFilter<"ChatMessage"> | Date | string
    chatId?: StringWithAggregatesFilter<"ChatMessage"> | string
    senderId?: StringWithAggregatesFilter<"ChatMessage"> | string
    expertId?: StringNullableWithAggregatesFilter<"ChatMessage"> | string | null
  }

  export type ClientReviewWhereInput = {
    AND?: ClientReviewWhereInput | ClientReviewWhereInput[]
    OR?: ClientReviewWhereInput[]
    NOT?: ClientReviewWhereInput | ClientReviewWhereInput[]
    id?: IntFilter<"ClientReview"> | number
    reviewText?: StringFilter<"ClientReview"> | string
    createdAt?: DateTimeFilter<"ClientReview"> | Date | string
    videoRoomId?: StringFilter<"ClientReview"> | string
    appointmentKey?: StringFilter<"ClientReview"> | string
    isDisplayed?: BoolFilter<"ClientReview"> | boolean
    clientId?: StringFilter<"ClientReview"> | string
    expertId?: StringFilter<"ClientReview"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }

  export type ClientReviewOrderByWithRelationInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
    appointment?: AppointmentOrderByWithRelationInput
    client?: UserOrderByWithRelationInput
    expert?: ExpertOrderByWithRelationInput
  }

  export type ClientReviewWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    videoRoomId?: string
    appointmentKey?: string
    AND?: ClientReviewWhereInput | ClientReviewWhereInput[]
    OR?: ClientReviewWhereInput[]
    NOT?: ClientReviewWhereInput | ClientReviewWhereInput[]
    reviewText?: StringFilter<"ClientReview"> | string
    createdAt?: DateTimeFilter<"ClientReview"> | Date | string
    isDisplayed?: BoolFilter<"ClientReview"> | boolean
    clientId?: StringFilter<"ClientReview"> | string
    expertId?: StringFilter<"ClientReview"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }, "id" | "videoRoomId" | "appointmentKey">

  export type ClientReviewOrderByWithAggregationInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
    _count?: ClientReviewCountOrderByAggregateInput
    _avg?: ClientReviewAvgOrderByAggregateInput
    _max?: ClientReviewMaxOrderByAggregateInput
    _min?: ClientReviewMinOrderByAggregateInput
    _sum?: ClientReviewSumOrderByAggregateInput
  }

  export type ClientReviewScalarWhereWithAggregatesInput = {
    AND?: ClientReviewScalarWhereWithAggregatesInput | ClientReviewScalarWhereWithAggregatesInput[]
    OR?: ClientReviewScalarWhereWithAggregatesInput[]
    NOT?: ClientReviewScalarWhereWithAggregatesInput | ClientReviewScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ClientReview"> | number
    reviewText?: StringWithAggregatesFilter<"ClientReview"> | string
    createdAt?: DateTimeWithAggregatesFilter<"ClientReview"> | Date | string
    videoRoomId?: StringWithAggregatesFilter<"ClientReview"> | string
    appointmentKey?: StringWithAggregatesFilter<"ClientReview"> | string
    isDisplayed?: BoolWithAggregatesFilter<"ClientReview"> | boolean
    clientId?: StringWithAggregatesFilter<"ClientReview"> | string
    expertId?: StringWithAggregatesFilter<"ClientReview"> | string
  }

  export type ExpertReviewWhereInput = {
    AND?: ExpertReviewWhereInput | ExpertReviewWhereInput[]
    OR?: ExpertReviewWhereInput[]
    NOT?: ExpertReviewWhereInput | ExpertReviewWhereInput[]
    id?: IntFilter<"ExpertReview"> | number
    reviewText?: StringNullableFilter<"ExpertReview"> | string | null
    createdAt?: DateTimeFilter<"ExpertReview"> | Date | string
    videoRoomId?: StringFilter<"ExpertReview"> | string
    expertId?: StringFilter<"ExpertReview"> | string
    appointmentKey?: StringFilter<"ExpertReview"> | string
    isDisplayed?: BoolFilter<"ExpertReview"> | boolean
    clientId?: StringFilter<"ExpertReview"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }

  export type ExpertReviewOrderByWithRelationInput = {
    id?: SortOrder
    reviewText?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    expertId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    appointment?: AppointmentOrderByWithRelationInput
    client?: UserOrderByWithRelationInput
    expert?: ExpertOrderByWithRelationInput
  }

  export type ExpertReviewWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    videoRoomId?: string
    appointmentKey?: string
    AND?: ExpertReviewWhereInput | ExpertReviewWhereInput[]
    OR?: ExpertReviewWhereInput[]
    NOT?: ExpertReviewWhereInput | ExpertReviewWhereInput[]
    reviewText?: StringNullableFilter<"ExpertReview"> | string | null
    createdAt?: DateTimeFilter<"ExpertReview"> | Date | string
    expertId?: StringFilter<"ExpertReview"> | string
    isDisplayed?: BoolFilter<"ExpertReview"> | boolean
    clientId?: StringFilter<"ExpertReview"> | string
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
    client?: XOR<UserRelationFilter, UserWhereInput>
    expert?: XOR<ExpertRelationFilter, ExpertWhereInput>
  }, "id" | "videoRoomId" | "appointmentKey">

  export type ExpertReviewOrderByWithAggregationInput = {
    id?: SortOrder
    reviewText?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    expertId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    _count?: ExpertReviewCountOrderByAggregateInput
    _avg?: ExpertReviewAvgOrderByAggregateInput
    _max?: ExpertReviewMaxOrderByAggregateInput
    _min?: ExpertReviewMinOrderByAggregateInput
    _sum?: ExpertReviewSumOrderByAggregateInput
  }

  export type ExpertReviewScalarWhereWithAggregatesInput = {
    AND?: ExpertReviewScalarWhereWithAggregatesInput | ExpertReviewScalarWhereWithAggregatesInput[]
    OR?: ExpertReviewScalarWhereWithAggregatesInput[]
    NOT?: ExpertReviewScalarWhereWithAggregatesInput | ExpertReviewScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ExpertReview"> | number
    reviewText?: StringNullableWithAggregatesFilter<"ExpertReview"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"ExpertReview"> | Date | string
    videoRoomId?: StringWithAggregatesFilter<"ExpertReview"> | string
    expertId?: StringWithAggregatesFilter<"ExpertReview"> | string
    appointmentKey?: StringWithAggregatesFilter<"ExpertReview"> | string
    isDisplayed?: BoolWithAggregatesFilter<"ExpertReview"> | boolean
    clientId?: StringWithAggregatesFilter<"ExpertReview"> | string
  }

  export type admin_invite_expertsWhereInput = {
    AND?: admin_invite_expertsWhereInput | admin_invite_expertsWhereInput[]
    OR?: admin_invite_expertsWhereInput[]
    NOT?: admin_invite_expertsWhereInput | admin_invite_expertsWhereInput[]
    id?: StringFilter<"admin_invite_experts"> | string
    firstName?: StringNullableFilter<"admin_invite_experts"> | string | null
    lastName?: StringNullableFilter<"admin_invite_experts"> | string | null
    created_at?: DateTimeFilter<"admin_invite_experts"> | Date | string
    email?: StringNullableFilter<"admin_invite_experts"> | string | null
    status?: EnumINVITE_STATUSFilter<"admin_invite_experts"> | $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    created_at?: SortOrder
    email?: SortOrderInput | SortOrder
    status?: SortOrder
  }

  export type admin_invite_expertsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: admin_invite_expertsWhereInput | admin_invite_expertsWhereInput[]
    OR?: admin_invite_expertsWhereInput[]
    NOT?: admin_invite_expertsWhereInput | admin_invite_expertsWhereInput[]
    firstName?: StringNullableFilter<"admin_invite_experts"> | string | null
    lastName?: StringNullableFilter<"admin_invite_experts"> | string | null
    created_at?: DateTimeFilter<"admin_invite_experts"> | Date | string
    email?: StringNullableFilter<"admin_invite_experts"> | string | null
    status?: EnumINVITE_STATUSFilter<"admin_invite_experts"> | $Enums.INVITE_STATUS
  }, "id">

  export type admin_invite_expertsOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    created_at?: SortOrder
    email?: SortOrderInput | SortOrder
    status?: SortOrder
    _count?: admin_invite_expertsCountOrderByAggregateInput
    _max?: admin_invite_expertsMaxOrderByAggregateInput
    _min?: admin_invite_expertsMinOrderByAggregateInput
  }

  export type admin_invite_expertsScalarWhereWithAggregatesInput = {
    AND?: admin_invite_expertsScalarWhereWithAggregatesInput | admin_invite_expertsScalarWhereWithAggregatesInput[]
    OR?: admin_invite_expertsScalarWhereWithAggregatesInput[]
    NOT?: admin_invite_expertsScalarWhereWithAggregatesInput | admin_invite_expertsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"admin_invite_experts"> | string
    firstName?: StringNullableWithAggregatesFilter<"admin_invite_experts"> | string | null
    lastName?: StringNullableWithAggregatesFilter<"admin_invite_experts"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"admin_invite_experts"> | Date | string
    email?: StringNullableWithAggregatesFilter<"admin_invite_experts"> | string | null
    status?: EnumINVITE_STATUSWithAggregatesFilter<"admin_invite_experts"> | $Enums.INVITE_STATUS
  }

  export type admin_mbc_cmsWhereInput = {
    AND?: admin_mbc_cmsWhereInput | admin_mbc_cmsWhereInput[]
    OR?: admin_mbc_cmsWhereInput[]
    NOT?: admin_mbc_cmsWhereInput | admin_mbc_cmsWhereInput[]
    id?: BigIntFilter<"admin_mbc_cms"> | bigint | number
    created_at?: DateTimeFilter<"admin_mbc_cms"> | Date | string
    section1_text?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section1_image?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section2_text?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section2_image?: StringNullableFilter<"admin_mbc_cms"> | string | null
    about_us_title?: StringNullableFilter<"admin_mbc_cms"> | string | null
    about_us_desc?: StringNullableFilter<"admin_mbc_cms"> | string | null
    general_condition_of_use?: StringNullableFilter<"admin_mbc_cms"> | string | null
    general_condition_of_sales?: StringNullableFilter<"admin_mbc_cms"> | string | null
    is_active?: IntNullableFilter<"admin_mbc_cms"> | number | null
    invite_email_content?: StringNullableFilter<"admin_mbc_cms"> | string | null
    invite_email_subject?: StringNullableFilter<"admin_mbc_cms"> | string | null
  }

  export type admin_mbc_cmsOrderByWithRelationInput = {
    id?: SortOrder
    created_at?: SortOrder
    section1_text?: SortOrderInput | SortOrder
    section1_image?: SortOrderInput | SortOrder
    section2_text?: SortOrderInput | SortOrder
    section2_image?: SortOrderInput | SortOrder
    about_us_title?: SortOrderInput | SortOrder
    about_us_desc?: SortOrderInput | SortOrder
    general_condition_of_use?: SortOrderInput | SortOrder
    general_condition_of_sales?: SortOrderInput | SortOrder
    is_active?: SortOrderInput | SortOrder
    invite_email_content?: SortOrderInput | SortOrder
    invite_email_subject?: SortOrderInput | SortOrder
  }

  export type admin_mbc_cmsWhereUniqueInput = Prisma.AtLeast<{
    id?: bigint | number
    AND?: admin_mbc_cmsWhereInput | admin_mbc_cmsWhereInput[]
    OR?: admin_mbc_cmsWhereInput[]
    NOT?: admin_mbc_cmsWhereInput | admin_mbc_cmsWhereInput[]
    created_at?: DateTimeFilter<"admin_mbc_cms"> | Date | string
    section1_text?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section1_image?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section2_text?: StringNullableFilter<"admin_mbc_cms"> | string | null
    section2_image?: StringNullableFilter<"admin_mbc_cms"> | string | null
    about_us_title?: StringNullableFilter<"admin_mbc_cms"> | string | null
    about_us_desc?: StringNullableFilter<"admin_mbc_cms"> | string | null
    general_condition_of_use?: StringNullableFilter<"admin_mbc_cms"> | string | null
    general_condition_of_sales?: StringNullableFilter<"admin_mbc_cms"> | string | null
    is_active?: IntNullableFilter<"admin_mbc_cms"> | number | null
    invite_email_content?: StringNullableFilter<"admin_mbc_cms"> | string | null
    invite_email_subject?: StringNullableFilter<"admin_mbc_cms"> | string | null
  }, "id">

  export type admin_mbc_cmsOrderByWithAggregationInput = {
    id?: SortOrder
    created_at?: SortOrder
    section1_text?: SortOrderInput | SortOrder
    section1_image?: SortOrderInput | SortOrder
    section2_text?: SortOrderInput | SortOrder
    section2_image?: SortOrderInput | SortOrder
    about_us_title?: SortOrderInput | SortOrder
    about_us_desc?: SortOrderInput | SortOrder
    general_condition_of_use?: SortOrderInput | SortOrder
    general_condition_of_sales?: SortOrderInput | SortOrder
    is_active?: SortOrderInput | SortOrder
    invite_email_content?: SortOrderInput | SortOrder
    invite_email_subject?: SortOrderInput | SortOrder
    _count?: admin_mbc_cmsCountOrderByAggregateInput
    _avg?: admin_mbc_cmsAvgOrderByAggregateInput
    _max?: admin_mbc_cmsMaxOrderByAggregateInput
    _min?: admin_mbc_cmsMinOrderByAggregateInput
    _sum?: admin_mbc_cmsSumOrderByAggregateInput
  }

  export type admin_mbc_cmsScalarWhereWithAggregatesInput = {
    AND?: admin_mbc_cmsScalarWhereWithAggregatesInput | admin_mbc_cmsScalarWhereWithAggregatesInput[]
    OR?: admin_mbc_cmsScalarWhereWithAggregatesInput[]
    NOT?: admin_mbc_cmsScalarWhereWithAggregatesInput | admin_mbc_cmsScalarWhereWithAggregatesInput[]
    id?: BigIntWithAggregatesFilter<"admin_mbc_cms"> | bigint | number
    created_at?: DateTimeWithAggregatesFilter<"admin_mbc_cms"> | Date | string
    section1_text?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    section1_image?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    section2_text?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    section2_image?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    about_us_title?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    about_us_desc?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    general_condition_of_use?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    general_condition_of_sales?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    is_active?: IntNullableWithAggregatesFilter<"admin_mbc_cms"> | number | null
    invite_email_content?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
    invite_email_subject?: StringNullableWithAggregatesFilter<"admin_mbc_cms"> | string | null
  }

  export type admin_mbc_faqsWhereInput = {
    AND?: admin_mbc_faqsWhereInput | admin_mbc_faqsWhereInput[]
    OR?: admin_mbc_faqsWhereInput[]
    NOT?: admin_mbc_faqsWhereInput | admin_mbc_faqsWhereInput[]
    id?: BigIntFilter<"admin_mbc_faqs"> | bigint | number
    created_at?: DateTimeFilter<"admin_mbc_faqs"> | Date | string
    question_title?: StringNullableFilter<"admin_mbc_faqs"> | string | null
    question_desc?: StringNullableFilter<"admin_mbc_faqs"> | string | null
  }

  export type admin_mbc_faqsOrderByWithRelationInput = {
    id?: SortOrder
    created_at?: SortOrder
    question_title?: SortOrderInput | SortOrder
    question_desc?: SortOrderInput | SortOrder
  }

  export type admin_mbc_faqsWhereUniqueInput = Prisma.AtLeast<{
    id?: bigint | number
    AND?: admin_mbc_faqsWhereInput | admin_mbc_faqsWhereInput[]
    OR?: admin_mbc_faqsWhereInput[]
    NOT?: admin_mbc_faqsWhereInput | admin_mbc_faqsWhereInput[]
    created_at?: DateTimeFilter<"admin_mbc_faqs"> | Date | string
    question_title?: StringNullableFilter<"admin_mbc_faqs"> | string | null
    question_desc?: StringNullableFilter<"admin_mbc_faqs"> | string | null
  }, "id">

  export type admin_mbc_faqsOrderByWithAggregationInput = {
    id?: SortOrder
    created_at?: SortOrder
    question_title?: SortOrderInput | SortOrder
    question_desc?: SortOrderInput | SortOrder
    _count?: admin_mbc_faqsCountOrderByAggregateInput
    _avg?: admin_mbc_faqsAvgOrderByAggregateInput
    _max?: admin_mbc_faqsMaxOrderByAggregateInput
    _min?: admin_mbc_faqsMinOrderByAggregateInput
    _sum?: admin_mbc_faqsSumOrderByAggregateInput
  }

  export type admin_mbc_faqsScalarWhereWithAggregatesInput = {
    AND?: admin_mbc_faqsScalarWhereWithAggregatesInput | admin_mbc_faqsScalarWhereWithAggregatesInput[]
    OR?: admin_mbc_faqsScalarWhereWithAggregatesInput[]
    NOT?: admin_mbc_faqsScalarWhereWithAggregatesInput | admin_mbc_faqsScalarWhereWithAggregatesInput[]
    id?: BigIntWithAggregatesFilter<"admin_mbc_faqs"> | bigint | number
    created_at?: DateTimeWithAggregatesFilter<"admin_mbc_faqs"> | Date | string
    question_title?: StringNullableWithAggregatesFilter<"admin_mbc_faqs"> | string | null
    question_desc?: StringNullableWithAggregatesFilter<"admin_mbc_faqs"> | string | null
  }

  export type admin_newsletterWhereInput = {
    AND?: admin_newsletterWhereInput | admin_newsletterWhereInput[]
    OR?: admin_newsletterWhereInput[]
    NOT?: admin_newsletterWhereInput | admin_newsletterWhereInput[]
    id?: BigIntFilter<"admin_newsletter"> | bigint | number
    created_at?: DateTimeFilter<"admin_newsletter"> | Date | string
    email?: StringNullableFilter<"admin_newsletter"> | string | null
    isUser?: BoolFilter<"admin_newsletter"> | boolean
    name?: StringNullableFilter<"admin_newsletter"> | string | null
  }

  export type admin_newsletterOrderByWithRelationInput = {
    id?: SortOrder
    created_at?: SortOrder
    email?: SortOrderInput | SortOrder
    isUser?: SortOrder
    name?: SortOrderInput | SortOrder
  }

  export type admin_newsletterWhereUniqueInput = Prisma.AtLeast<{
    id?: bigint | number
    AND?: admin_newsletterWhereInput | admin_newsletterWhereInput[]
    OR?: admin_newsletterWhereInput[]
    NOT?: admin_newsletterWhereInput | admin_newsletterWhereInput[]
    created_at?: DateTimeFilter<"admin_newsletter"> | Date | string
    email?: StringNullableFilter<"admin_newsletter"> | string | null
    isUser?: BoolFilter<"admin_newsletter"> | boolean
    name?: StringNullableFilter<"admin_newsletter"> | string | null
  }, "id">

  export type admin_newsletterOrderByWithAggregationInput = {
    id?: SortOrder
    created_at?: SortOrder
    email?: SortOrderInput | SortOrder
    isUser?: SortOrder
    name?: SortOrderInput | SortOrder
    _count?: admin_newsletterCountOrderByAggregateInput
    _avg?: admin_newsletterAvgOrderByAggregateInput
    _max?: admin_newsletterMaxOrderByAggregateInput
    _min?: admin_newsletterMinOrderByAggregateInput
    _sum?: admin_newsletterSumOrderByAggregateInput
  }

  export type admin_newsletterScalarWhereWithAggregatesInput = {
    AND?: admin_newsletterScalarWhereWithAggregatesInput | admin_newsletterScalarWhereWithAggregatesInput[]
    OR?: admin_newsletterScalarWhereWithAggregatesInput[]
    NOT?: admin_newsletterScalarWhereWithAggregatesInput | admin_newsletterScalarWhereWithAggregatesInput[]
    id?: BigIntWithAggregatesFilter<"admin_newsletter"> | bigint | number
    created_at?: DateTimeWithAggregatesFilter<"admin_newsletter"> | Date | string
    email?: StringNullableWithAggregatesFilter<"admin_newsletter"> | string | null
    isUser?: BoolWithAggregatesFilter<"admin_newsletter"> | boolean
    name?: StringNullableWithAggregatesFilter<"admin_newsletter"> | string | null
  }

  export type admin_userWhereInput = {
    AND?: admin_userWhereInput | admin_userWhereInput[]
    OR?: admin_userWhereInput[]
    NOT?: admin_userWhereInput | admin_userWhereInput[]
    id?: StringFilter<"admin_user"> | string
    created_at?: DateTimeFilter<"admin_user"> | Date | string
    role?: EnumAdminRoleNullableFilter<"admin_user"> | $Enums.AdminRole | null
    user_id?: StringFilter<"admin_user"> | string
    User?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type admin_userOrderByWithRelationInput = {
    id?: SortOrder
    created_at?: SortOrder
    role?: SortOrderInput | SortOrder
    user_id?: SortOrder
    User?: UserOrderByWithRelationInput
  }

  export type admin_userWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    user_id?: string
    AND?: admin_userWhereInput | admin_userWhereInput[]
    OR?: admin_userWhereInput[]
    NOT?: admin_userWhereInput | admin_userWhereInput[]
    created_at?: DateTimeFilter<"admin_user"> | Date | string
    role?: EnumAdminRoleNullableFilter<"admin_user"> | $Enums.AdminRole | null
    User?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id" | "user_id">

  export type admin_userOrderByWithAggregationInput = {
    id?: SortOrder
    created_at?: SortOrder
    role?: SortOrderInput | SortOrder
    user_id?: SortOrder
    _count?: admin_userCountOrderByAggregateInput
    _max?: admin_userMaxOrderByAggregateInput
    _min?: admin_userMinOrderByAggregateInput
  }

  export type admin_userScalarWhereWithAggregatesInput = {
    AND?: admin_userScalarWhereWithAggregatesInput | admin_userScalarWhereWithAggregatesInput[]
    OR?: admin_userScalarWhereWithAggregatesInput[]
    NOT?: admin_userScalarWhereWithAggregatesInput | admin_userScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"admin_user"> | string
    created_at?: DateTimeWithAggregatesFilter<"admin_user"> | Date | string
    role?: EnumAdminRoleNullableWithAggregatesFilter<"admin_user"> | $Enums.AdminRole | null
    user_id?: StringWithAggregatesFilter<"admin_user"> | string
  }

  export type faqQuestionWhereInput = {
    AND?: faqQuestionWhereInput | faqQuestionWhereInput[]
    OR?: faqQuestionWhereInput[]
    NOT?: faqQuestionWhereInput | faqQuestionWhereInput[]
    id?: IntFilter<"faqQuestion"> | number
    question?: StringFilter<"faqQuestion"> | string
    answer?: StringFilter<"faqQuestion"> | string
    created_at?: DateTimeFilter<"faqQuestion"> | Date | string
  }

  export type faqQuestionOrderByWithRelationInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
  }

  export type faqQuestionWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: faqQuestionWhereInput | faqQuestionWhereInput[]
    OR?: faqQuestionWhereInput[]
    NOT?: faqQuestionWhereInput | faqQuestionWhereInput[]
    question?: StringFilter<"faqQuestion"> | string
    answer?: StringFilter<"faqQuestion"> | string
    created_at?: DateTimeFilter<"faqQuestion"> | Date | string
  }, "id">

  export type faqQuestionOrderByWithAggregationInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    _count?: faqQuestionCountOrderByAggregateInput
    _avg?: faqQuestionAvgOrderByAggregateInput
    _max?: faqQuestionMaxOrderByAggregateInput
    _min?: faqQuestionMinOrderByAggregateInput
    _sum?: faqQuestionSumOrderByAggregateInput
  }

  export type faqQuestionScalarWhereWithAggregatesInput = {
    AND?: faqQuestionScalarWhereWithAggregatesInput | faqQuestionScalarWhereWithAggregatesInput[]
    OR?: faqQuestionScalarWhereWithAggregatesInput[]
    NOT?: faqQuestionScalarWhereWithAggregatesInput | faqQuestionScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"faqQuestion"> | number
    question?: StringWithAggregatesFilter<"faqQuestion"> | string
    answer?: StringWithAggregatesFilter<"faqQuestion"> | string
    created_at?: DateTimeWithAggregatesFilter<"faqQuestion"> | Date | string
  }

  export type sessionWhereInput = {
    AND?: sessionWhereInput | sessionWhereInput[]
    OR?: sessionWhereInput[]
    NOT?: sessionWhereInput | sessionWhereInput[]
    id?: StringFilter<"session"> | string
    user_id?: StringFilter<"session"> | string
    active_expires?: BigIntFilter<"session"> | bigint | number
    idle_expires?: BigIntFilter<"session"> | bigint | number
    User?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type sessionOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    active_expires?: SortOrder
    idle_expires?: SortOrder
    User?: UserOrderByWithRelationInput
  }

  export type sessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: sessionWhereInput | sessionWhereInput[]
    OR?: sessionWhereInput[]
    NOT?: sessionWhereInput | sessionWhereInput[]
    user_id?: StringFilter<"session"> | string
    active_expires?: BigIntFilter<"session"> | bigint | number
    idle_expires?: BigIntFilter<"session"> | bigint | number
    User?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type sessionOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    active_expires?: SortOrder
    idle_expires?: SortOrder
    _count?: sessionCountOrderByAggregateInput
    _avg?: sessionAvgOrderByAggregateInput
    _max?: sessionMaxOrderByAggregateInput
    _min?: sessionMinOrderByAggregateInput
    _sum?: sessionSumOrderByAggregateInput
  }

  export type sessionScalarWhereWithAggregatesInput = {
    AND?: sessionScalarWhereWithAggregatesInput | sessionScalarWhereWithAggregatesInput[]
    OR?: sessionScalarWhereWithAggregatesInput[]
    NOT?: sessionScalarWhereWithAggregatesInput | sessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"session"> | string
    user_id?: StringWithAggregatesFilter<"session"> | string
    active_expires?: BigIntWithAggregatesFilter<"session"> | bigint | number
    idle_expires?: BigIntWithAggregatesFilter<"session"> | bigint | number
  }

  export type admin_editingWhereInput = {
    AND?: admin_editingWhereInput | admin_editingWhereInput[]
    OR?: admin_editingWhereInput[]
    NOT?: admin_editingWhereInput | admin_editingWhereInput[]
    id?: IntFilter<"admin_editing"> | number
    updatedAt?: DateTimeFilter<"admin_editing"> | Date | string
    genericEmailBody?: StringNullableFilter<"admin_editing"> | string | null
    genericEmailHeader?: StringNullableFilter<"admin_editing"> | string | null
    aboutContent?: StringNullableFilter<"admin_editing"> | string | null
    aboutImageUrl?: StringNullableFilter<"admin_editing"> | string | null
    landingPageDesc?: StringNullableFilter<"admin_editing"> | string | null
    landingPageHeading?: StringNullableFilter<"admin_editing"> | string | null
    landingPageHero?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionDesc?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionHeading?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionHero?: StringNullableFilter<"admin_editing"> | string | null
    conditionsSale?: StringNullableFilter<"admin_editing"> | string | null
    conditionsUse?: StringNullableFilter<"admin_editing"> | string | null
    privacyPolicy?: StringNullableFilter<"admin_editing"> | string | null
  }

  export type admin_editingOrderByWithRelationInput = {
    id?: SortOrder
    updatedAt?: SortOrder
    genericEmailBody?: SortOrderInput | SortOrder
    genericEmailHeader?: SortOrderInput | SortOrder
    aboutContent?: SortOrderInput | SortOrder
    aboutImageUrl?: SortOrderInput | SortOrder
    landingPageDesc?: SortOrderInput | SortOrder
    landingPageHeading?: SortOrderInput | SortOrder
    landingPageHero?: SortOrderInput | SortOrder
    landingPageSectionDesc?: SortOrderInput | SortOrder
    landingPageSectionHeading?: SortOrderInput | SortOrder
    landingPageSectionHero?: SortOrderInput | SortOrder
    conditionsSale?: SortOrderInput | SortOrder
    conditionsUse?: SortOrderInput | SortOrder
    privacyPolicy?: SortOrderInput | SortOrder
  }

  export type admin_editingWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: admin_editingWhereInput | admin_editingWhereInput[]
    OR?: admin_editingWhereInput[]
    NOT?: admin_editingWhereInput | admin_editingWhereInput[]
    updatedAt?: DateTimeFilter<"admin_editing"> | Date | string
    genericEmailBody?: StringNullableFilter<"admin_editing"> | string | null
    genericEmailHeader?: StringNullableFilter<"admin_editing"> | string | null
    aboutContent?: StringNullableFilter<"admin_editing"> | string | null
    aboutImageUrl?: StringNullableFilter<"admin_editing"> | string | null
    landingPageDesc?: StringNullableFilter<"admin_editing"> | string | null
    landingPageHeading?: StringNullableFilter<"admin_editing"> | string | null
    landingPageHero?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionDesc?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionHeading?: StringNullableFilter<"admin_editing"> | string | null
    landingPageSectionHero?: StringNullableFilter<"admin_editing"> | string | null
    conditionsSale?: StringNullableFilter<"admin_editing"> | string | null
    conditionsUse?: StringNullableFilter<"admin_editing"> | string | null
    privacyPolicy?: StringNullableFilter<"admin_editing"> | string | null
  }, "id" | "id">

  export type admin_editingOrderByWithAggregationInput = {
    id?: SortOrder
    updatedAt?: SortOrder
    genericEmailBody?: SortOrderInput | SortOrder
    genericEmailHeader?: SortOrderInput | SortOrder
    aboutContent?: SortOrderInput | SortOrder
    aboutImageUrl?: SortOrderInput | SortOrder
    landingPageDesc?: SortOrderInput | SortOrder
    landingPageHeading?: SortOrderInput | SortOrder
    landingPageHero?: SortOrderInput | SortOrder
    landingPageSectionDesc?: SortOrderInput | SortOrder
    landingPageSectionHeading?: SortOrderInput | SortOrder
    landingPageSectionHero?: SortOrderInput | SortOrder
    conditionsSale?: SortOrderInput | SortOrder
    conditionsUse?: SortOrderInput | SortOrder
    privacyPolicy?: SortOrderInput | SortOrder
    _count?: admin_editingCountOrderByAggregateInput
    _avg?: admin_editingAvgOrderByAggregateInput
    _max?: admin_editingMaxOrderByAggregateInput
    _min?: admin_editingMinOrderByAggregateInput
    _sum?: admin_editingSumOrderByAggregateInput
  }

  export type admin_editingScalarWhereWithAggregatesInput = {
    AND?: admin_editingScalarWhereWithAggregatesInput | admin_editingScalarWhereWithAggregatesInput[]
    OR?: admin_editingScalarWhereWithAggregatesInput[]
    NOT?: admin_editingScalarWhereWithAggregatesInput | admin_editingScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"admin_editing"> | number
    updatedAt?: DateTimeWithAggregatesFilter<"admin_editing"> | Date | string
    genericEmailBody?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    genericEmailHeader?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    aboutContent?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    aboutImageUrl?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageDesc?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageHeading?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageHero?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageSectionDesc?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageSectionHeading?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    landingPageSectionHero?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    conditionsSale?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    conditionsUse?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
    privacyPolicy?: StringNullableWithAggregatesFilter<"admin_editing"> | string | null
  }

  export type admin_notificationWhereInput = {
    AND?: admin_notificationWhereInput | admin_notificationWhereInput[]
    OR?: admin_notificationWhereInput[]
    NOT?: admin_notificationWhereInput | admin_notificationWhereInput[]
    id?: IntFilter<"admin_notification"> | number
    created_at?: DateTimeFilter<"admin_notification"> | Date | string
    title?: StringFilter<"admin_notification"> | string
    link?: StringNullableFilter<"admin_notification"> | string | null
    description?: StringFilter<"admin_notification"> | string
  }

  export type admin_notificationOrderByWithRelationInput = {
    id?: SortOrder
    created_at?: SortOrder
    title?: SortOrder
    link?: SortOrderInput | SortOrder
    description?: SortOrder
  }

  export type admin_notificationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: admin_notificationWhereInput | admin_notificationWhereInput[]
    OR?: admin_notificationWhereInput[]
    NOT?: admin_notificationWhereInput | admin_notificationWhereInput[]
    created_at?: DateTimeFilter<"admin_notification"> | Date | string
    title?: StringFilter<"admin_notification"> | string
    link?: StringNullableFilter<"admin_notification"> | string | null
    description?: StringFilter<"admin_notification"> | string
  }, "id" | "id">

  export type admin_notificationOrderByWithAggregationInput = {
    id?: SortOrder
    created_at?: SortOrder
    title?: SortOrder
    link?: SortOrderInput | SortOrder
    description?: SortOrder
    _count?: admin_notificationCountOrderByAggregateInput
    _avg?: admin_notificationAvgOrderByAggregateInput
    _max?: admin_notificationMaxOrderByAggregateInput
    _min?: admin_notificationMinOrderByAggregateInput
    _sum?: admin_notificationSumOrderByAggregateInput
  }

  export type admin_notificationScalarWhereWithAggregatesInput = {
    AND?: admin_notificationScalarWhereWithAggregatesInput | admin_notificationScalarWhereWithAggregatesInput[]
    OR?: admin_notificationScalarWhereWithAggregatesInput[]
    NOT?: admin_notificationScalarWhereWithAggregatesInput | admin_notificationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"admin_notification"> | number
    created_at?: DateTimeWithAggregatesFilter<"admin_notification"> | Date | string
    title?: StringWithAggregatesFilter<"admin_notification"> | string
    link?: StringNullableWithAggregatesFilter<"admin_notification"> | string | null
    description?: StringWithAggregatesFilter<"admin_notification"> | string
  }

  export type admin_notification_statusWhereInput = {
    AND?: admin_notification_statusWhereInput | admin_notification_statusWhereInput[]
    OR?: admin_notification_statusWhereInput[]
    NOT?: admin_notification_statusWhereInput | admin_notification_statusWhereInput[]
    id?: IntFilter<"admin_notification_status"> | number
    status?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
  }

  export type admin_notification_statusOrderByWithRelationInput = {
    id?: SortOrder
    status?: SortOrder
    newExpertApplication?: SortOrder
    newInvitationAccepted?: SortOrder
    newIdVerification?: SortOrder
  }

  export type admin_notification_statusWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: admin_notification_statusWhereInput | admin_notification_statusWhereInput[]
    OR?: admin_notification_statusWhereInput[]
    NOT?: admin_notification_statusWhereInput | admin_notification_statusWhereInput[]
    status?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFilter<"admin_notification_status"> | $Enums.NotificationStatus
  }, "id" | "id">

  export type admin_notification_statusOrderByWithAggregationInput = {
    id?: SortOrder
    status?: SortOrder
    newExpertApplication?: SortOrder
    newInvitationAccepted?: SortOrder
    newIdVerification?: SortOrder
    _count?: admin_notification_statusCountOrderByAggregateInput
    _avg?: admin_notification_statusAvgOrderByAggregateInput
    _max?: admin_notification_statusMaxOrderByAggregateInput
    _min?: admin_notification_statusMinOrderByAggregateInput
    _sum?: admin_notification_statusSumOrderByAggregateInput
  }

  export type admin_notification_statusScalarWhereWithAggregatesInput = {
    AND?: admin_notification_statusScalarWhereWithAggregatesInput | admin_notification_statusScalarWhereWithAggregatesInput[]
    OR?: admin_notification_statusScalarWhereWithAggregatesInput[]
    NOT?: admin_notification_statusScalarWhereWithAggregatesInput | admin_notification_statusScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"admin_notification_status"> | number
    status?: EnumNotificationStatusWithAggregatesFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusWithAggregatesFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusWithAggregatesFilter<"admin_notification_status"> | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusWithAggregatesFilter<"admin_notification_status"> | $Enums.NotificationStatus
  }

  export type expertApplicationAnswerWhereInput = {
    AND?: expertApplicationAnswerWhereInput | expertApplicationAnswerWhereInput[]
    OR?: expertApplicationAnswerWhereInput[]
    NOT?: expertApplicationAnswerWhereInput | expertApplicationAnswerWhereInput[]
    id?: StringFilter<"expertApplicationAnswer"> | string
    answer?: StringFilter<"expertApplicationAnswer"> | string
    created_at?: DateTimeFilter<"expertApplicationAnswer"> | Date | string
    userId?: StringFilter<"expertApplicationAnswer"> | string
    questionId?: StringFilter<"expertApplicationAnswer"> | string
    admin_expert_applicationId?: StringNullableFilter<"expertApplicationAnswer"> | string | null
    admin_expert_application?: XOR<Admin_expert_applicationNullableRelationFilter, admin_expert_applicationWhereInput> | null
    expertApplicationQuestion?: XOR<ExpertApplicationQuestionRelationFilter, expertApplicationQuestionWhereInput>
    User?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type expertApplicationAnswerOrderByWithRelationInput = {
    id?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    userId?: SortOrder
    questionId?: SortOrder
    admin_expert_applicationId?: SortOrderInput | SortOrder
    admin_expert_application?: admin_expert_applicationOrderByWithRelationInput
    expertApplicationQuestion?: expertApplicationQuestionOrderByWithRelationInput
    User?: UserOrderByWithRelationInput
  }

  export type expertApplicationAnswerWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: expertApplicationAnswerWhereInput | expertApplicationAnswerWhereInput[]
    OR?: expertApplicationAnswerWhereInput[]
    NOT?: expertApplicationAnswerWhereInput | expertApplicationAnswerWhereInput[]
    answer?: StringFilter<"expertApplicationAnswer"> | string
    created_at?: DateTimeFilter<"expertApplicationAnswer"> | Date | string
    userId?: StringFilter<"expertApplicationAnswer"> | string
    questionId?: StringFilter<"expertApplicationAnswer"> | string
    admin_expert_applicationId?: StringNullableFilter<"expertApplicationAnswer"> | string | null
    admin_expert_application?: XOR<Admin_expert_applicationNullableRelationFilter, admin_expert_applicationWhereInput> | null
    expertApplicationQuestion?: XOR<ExpertApplicationQuestionRelationFilter, expertApplicationQuestionWhereInput>
    User?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "id">

  export type expertApplicationAnswerOrderByWithAggregationInput = {
    id?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    userId?: SortOrder
    questionId?: SortOrder
    admin_expert_applicationId?: SortOrderInput | SortOrder
    _count?: expertApplicationAnswerCountOrderByAggregateInput
    _max?: expertApplicationAnswerMaxOrderByAggregateInput
    _min?: expertApplicationAnswerMinOrderByAggregateInput
  }

  export type expertApplicationAnswerScalarWhereWithAggregatesInput = {
    AND?: expertApplicationAnswerScalarWhereWithAggregatesInput | expertApplicationAnswerScalarWhereWithAggregatesInput[]
    OR?: expertApplicationAnswerScalarWhereWithAggregatesInput[]
    NOT?: expertApplicationAnswerScalarWhereWithAggregatesInput | expertApplicationAnswerScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"expertApplicationAnswer"> | string
    answer?: StringWithAggregatesFilter<"expertApplicationAnswer"> | string
    created_at?: DateTimeWithAggregatesFilter<"expertApplicationAnswer"> | Date | string
    userId?: StringWithAggregatesFilter<"expertApplicationAnswer"> | string
    questionId?: StringWithAggregatesFilter<"expertApplicationAnswer"> | string
    admin_expert_applicationId?: StringNullableWithAggregatesFilter<"expertApplicationAnswer"> | string | null
  }

  export type admin_expert_applicationWhereInput = {
    AND?: admin_expert_applicationWhereInput | admin_expert_applicationWhereInput[]
    OR?: admin_expert_applicationWhereInput[]
    NOT?: admin_expert_applicationWhereInput | admin_expert_applicationWhereInput[]
    id?: StringFilter<"admin_expert_application"> | string
    status?: EnumStatusFilter<"admin_expert_application"> | $Enums.Status
    createdAt?: DateTimeFilter<"admin_expert_application"> | Date | string
    userId?: StringFilter<"admin_expert_application"> | string
    User?: XOR<UserRelationFilter, UserWhereInput>
    answer?: ExpertApplicationAnswerListRelationFilter
  }

  export type admin_expert_applicationOrderByWithRelationInput = {
    id?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    userId?: SortOrder
    User?: UserOrderByWithRelationInput
    answer?: expertApplicationAnswerOrderByRelationAggregateInput
  }

  export type admin_expert_applicationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: admin_expert_applicationWhereInput | admin_expert_applicationWhereInput[]
    OR?: admin_expert_applicationWhereInput[]
    NOT?: admin_expert_applicationWhereInput | admin_expert_applicationWhereInput[]
    status?: EnumStatusFilter<"admin_expert_application"> | $Enums.Status
    createdAt?: DateTimeFilter<"admin_expert_application"> | Date | string
    userId?: StringFilter<"admin_expert_application"> | string
    User?: XOR<UserRelationFilter, UserWhereInput>
    answer?: ExpertApplicationAnswerListRelationFilter
  }, "id">

  export type admin_expert_applicationOrderByWithAggregationInput = {
    id?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    userId?: SortOrder
    _count?: admin_expert_applicationCountOrderByAggregateInput
    _max?: admin_expert_applicationMaxOrderByAggregateInput
    _min?: admin_expert_applicationMinOrderByAggregateInput
  }

  export type admin_expert_applicationScalarWhereWithAggregatesInput = {
    AND?: admin_expert_applicationScalarWhereWithAggregatesInput | admin_expert_applicationScalarWhereWithAggregatesInput[]
    OR?: admin_expert_applicationScalarWhereWithAggregatesInput[]
    NOT?: admin_expert_applicationScalarWhereWithAggregatesInput | admin_expert_applicationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"admin_expert_application"> | string
    status?: EnumStatusWithAggregatesFilter<"admin_expert_application"> | $Enums.Status
    createdAt?: DateTimeWithAggregatesFilter<"admin_expert_application"> | Date | string
    userId?: StringWithAggregatesFilter<"admin_expert_application"> | string
  }

  export type expertApplicationQuestionWhereInput = {
    AND?: expertApplicationQuestionWhereInput | expertApplicationQuestionWhereInput[]
    OR?: expertApplicationQuestionWhereInput[]
    NOT?: expertApplicationQuestionWhereInput | expertApplicationQuestionWhereInput[]
    id?: StringFilter<"expertApplicationQuestion"> | string
    question?: StringFilter<"expertApplicationQuestion"> | string
    created_at?: DateTimeFilter<"expertApplicationQuestion"> | Date | string
    order?: IntFilter<"expertApplicationQuestion"> | number
    expertApplicationAnswer?: ExpertApplicationAnswerListRelationFilter
  }

  export type expertApplicationQuestionOrderByWithRelationInput = {
    id?: SortOrder
    question?: SortOrder
    created_at?: SortOrder
    order?: SortOrder
    expertApplicationAnswer?: expertApplicationAnswerOrderByRelationAggregateInput
  }

  export type expertApplicationQuestionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: expertApplicationQuestionWhereInput | expertApplicationQuestionWhereInput[]
    OR?: expertApplicationQuestionWhereInput[]
    NOT?: expertApplicationQuestionWhereInput | expertApplicationQuestionWhereInput[]
    question?: StringFilter<"expertApplicationQuestion"> | string
    created_at?: DateTimeFilter<"expertApplicationQuestion"> | Date | string
    order?: IntFilter<"expertApplicationQuestion"> | number
    expertApplicationAnswer?: ExpertApplicationAnswerListRelationFilter
  }, "id" | "id">

  export type expertApplicationQuestionOrderByWithAggregationInput = {
    id?: SortOrder
    question?: SortOrder
    created_at?: SortOrder
    order?: SortOrder
    _count?: expertApplicationQuestionCountOrderByAggregateInput
    _avg?: expertApplicationQuestionAvgOrderByAggregateInput
    _max?: expertApplicationQuestionMaxOrderByAggregateInput
    _min?: expertApplicationQuestionMinOrderByAggregateInput
    _sum?: expertApplicationQuestionSumOrderByAggregateInput
  }

  export type expertApplicationQuestionScalarWhereWithAggregatesInput = {
    AND?: expertApplicationQuestionScalarWhereWithAggregatesInput | expertApplicationQuestionScalarWhereWithAggregatesInput[]
    OR?: expertApplicationQuestionScalarWhereWithAggregatesInput[]
    NOT?: expertApplicationQuestionScalarWhereWithAggregatesInput | expertApplicationQuestionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"expertApplicationQuestion"> | string
    question?: StringWithAggregatesFilter<"expertApplicationQuestion"> | string
    created_at?: DateTimeWithAggregatesFilter<"expertApplicationQuestion"> | Date | string
    order?: IntWithAggregatesFilter<"expertApplicationQuestion"> | number
  }

  export type UserCreateInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
  }

  export type ExpertCreateInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type ExpertCreateManyInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
  }

  export type ExpertUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExpertUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type id_verificationCreateInput = {
    status?: $Enums.Status
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
    user: UserCreateNestedOneWithoutId_verificationInput
  }

  export type id_verificationUncheckedCreateInput = {
    id?: number
    status?: $Enums.Status
    userId: string
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
  }

  export type id_verificationUpdateInput = {
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
    user?: UserUpdateOneRequiredWithoutId_verificationNestedInput
  }

  export type id_verificationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    userId?: StringFieldUpdateOperationsInput | string
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type id_verificationCreateManyInput = {
    id?: number
    status?: $Enums.Status
    userId: string
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
  }

  export type id_verificationUpdateManyMutationInput = {
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type id_verificationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    userId?: StringFieldUpdateOperationsInput | string
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type email_verification_tokenCreateInput = {
    id: string
    expires: bigint | number
    user: UserCreateNestedOneWithoutEmail_verification_tokenInput
  }

  export type email_verification_tokenUncheckedCreateInput = {
    id: string
    expires: bigint | number
    userId: string
  }

  export type email_verification_tokenUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
    user?: UserUpdateOneRequiredWithoutEmail_verification_tokenNestedInput
  }

  export type email_verification_tokenUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type email_verification_tokenCreateManyInput = {
    id: string
    expires: bigint | number
    userId: string
  }

  export type email_verification_tokenUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type email_verification_tokenUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionCreateInput = {
    content: string
    user: UserCreateNestedOneWithoutQuestionsInput
  }

  export type QuestionUncheckedCreateInput = {
    id?: number
    content: string
    userId: string
  }

  export type QuestionUpdateInput = {
    content?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutQuestionsNestedInput
  }

  export type QuestionUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionCreateManyInput = {
    id?: number
    content: string
    userId: string
  }

  export type QuestionUpdateManyMutationInput = {
    content?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyCreateInput = {
    content: string
    questionContent: string
    appointment: AppointmentCreateNestedOneWithoutReplyInput
    user: UserCreateNestedOneWithoutReplyInput
  }

  export type ReplyUncheckedCreateInput = {
    id?: number
    content: string
    appointmentKey: string
    questionContent: string
    userId: string
  }

  export type ReplyUpdateInput = {
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    appointment?: AppointmentUpdateOneRequiredWithoutReplyNestedInput
    user?: UserUpdateOneRequiredWithoutReplyNestedInput
  }

  export type ReplyUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyCreateManyInput = {
    id?: number
    content: string
    appointmentKey: string
    questionContent: string
    userId: string
  }

  export type ReplyUpdateManyMutationInput = {
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type StripeAccountCreateInput = {
    stripeData: JsonNullValueInput | InputJsonValue
    expert: ExpertCreateNestedOneWithoutStripeAccountInput
  }

  export type StripeAccountUncheckedCreateInput = {
    id?: number
    stripeData: JsonNullValueInput | InputJsonValue
    expertId: string
  }

  export type StripeAccountUpdateInput = {
    stripeData?: JsonNullValueInput | InputJsonValue
    expert?: ExpertUpdateOneRequiredWithoutStripeAccountNestedInput
  }

  export type StripeAccountUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    stripeData?: JsonNullValueInput | InputJsonValue
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type StripeAccountCreateManyInput = {
    id?: number
    stripeData: JsonNullValueInput | InputJsonValue
    expertId: string
  }

  export type StripeAccountUpdateManyMutationInput = {
    stripeData?: JsonNullValueInput | InputJsonValue
  }

  export type StripeAccountUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    stripeData?: JsonNullValueInput | InputJsonValue
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type KeyCreateInput = {
    id: string
    hashed_password?: string | null
    user: UserCreateNestedOneWithoutKeyInput
  }

  export type KeyUncheckedCreateInput = {
    id: string
    hashed_password?: string | null
    user_id: string
  }

  export type KeyUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneRequiredWithoutKeyNestedInput
  }

  export type KeyUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
  }

  export type KeyCreateManyInput = {
    id: string
    hashed_password?: string | null
    user_id: string
  }

  export type KeyUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type KeyUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
  }

  export type ExperienceCreateInput = {
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    endDate?: Date | string | null
    startDate?: Date | string | null
    user: UserCreateNestedOneWithoutExperiencesInput
  }

  export type ExperienceUncheckedCreateInput = {
    id?: number
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    userId: string
    endDate?: Date | string | null
    startDate?: Date | string | null
  }

  export type ExperienceUpdateInput = {
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutExperiencesNestedInput
  }

  export type ExperienceUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExperienceCreateManyInput = {
    id?: number
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    userId: string
    endDate?: Date | string | null
    startDate?: Date | string | null
  }

  export type ExperienceUpdateManyMutationInput = {
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExperienceUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type EducationCreateInput = {
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
    user: UserCreateNestedOneWithoutEducationsInput
  }

  export type EducationUncheckedCreateInput = {
    id?: number
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    userId: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type EducationUpdateInput = {
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutEducationsNestedInput
  }

  export type EducationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type EducationCreateManyInput = {
    id?: number
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    userId: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type EducationUpdateManyMutationInput = {
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type EducationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertiseCreateInput = {
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
    user: UserCreateNestedOneWithoutExpertisesInput
  }

  export type ExpertiseUncheckedCreateInput = {
    id?: number
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    userId: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type ExpertiseUpdateInput = {
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutExpertisesNestedInput
  }

  export type ExpertiseUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertiseCreateManyInput = {
    id?: number
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    userId: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type ExpertiseUpdateManyMutationInput = {
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertiseUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type LanguageCreateInput = {
    name?: string
    user: UserCreateNestedOneWithoutLanguagesSpokenInput
  }

  export type LanguageUncheckedCreateInput = {
    id?: number
    name?: string
    userId: string
  }

  export type LanguageUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutLanguagesSpokenNestedInput
  }

  export type LanguageUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type LanguageCreateManyInput = {
    id?: number
    name?: string
    userId: string
  }

  export type LanguageUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
  }

  export type LanguageUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentCreateInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    client: UserCreateNestedOneWithoutAppointmentInput
    expert: ExpertCreateNestedOneWithoutAppointmentInput
    receivedClientReviews?: ClientReviewCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewCreateNestedOneWithoutAppointmentInput
    reply?: ReplyCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateInput = {
    id?: number
    clientId: string
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    receivedClientReviews?: ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput
    reply?: ReplyUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUpdateInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    client?: UserUpdateOneRequiredWithoutAppointmentNestedInput
    expert?: ExpertUpdateOneRequiredWithoutAppointmentNestedInput
    receivedClientReviews?: ClientReviewUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    receivedClientReviews?: ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentCreateManyInput = {
    id?: number
    clientId: string
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
  }

  export type AppointmentUpdateManyMutationInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AvailabilityCreateInput = {
    day: string
    timezone: string
    expert: ExpertCreateNestedOneWithoutAvailabilitiesInput
    user?: UserCreateNestedOneWithoutAvailabilitiesInput
    slots?: SlotCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityUncheckedCreateInput = {
    id?: number
    day: string
    timezone: string
    expertId: string
    userId?: string | null
    slots?: SlotUncheckedCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityUpdateInput = {
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expert?: ExpertUpdateOneRequiredWithoutAvailabilitiesNestedInput
    user?: UserUpdateOneWithoutAvailabilitiesNestedInput
    slots?: SlotUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    slots?: SlotUncheckedUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityCreateManyInput = {
    id?: number
    day: string
    timezone: string
    expertId: string
    userId?: string | null
  }

  export type AvailabilityUpdateManyMutationInput = {
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
  }

  export type AvailabilityUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SlotCreateInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId: string
    exceptions?: ExceptionCreateNestedManyWithoutSlotInput
    Availability: AvailabilityCreateNestedOneWithoutSlotsInput
  }

  export type SlotUncheckedCreateInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    availabilityId: number
    hide?: boolean
    isSplit?: boolean
    originalId: string
    exceptions?: ExceptionUncheckedCreateNestedManyWithoutSlotInput
  }

  export type SlotUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
    exceptions?: ExceptionUpdateManyWithoutSlotNestedInput
    Availability?: AvailabilityUpdateOneRequiredWithoutSlotsNestedInput
  }

  export type SlotUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    availabilityId?: IntFieldUpdateOperationsInput | number
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
    exceptions?: ExceptionUncheckedUpdateManyWithoutSlotNestedInput
  }

  export type SlotCreateManyInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    availabilityId: number
    hide?: boolean
    isSplit?: boolean
    originalId: string
  }

  export type SlotUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
  }

  export type SlotUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    availabilityId?: IntFieldUpdateOperationsInput | number
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionCreateInput = {
    date: string
    Slot: SlotCreateNestedOneWithoutExceptionsInput
  }

  export type ExceptionUncheckedCreateInput = {
    id?: number
    date: string
    slotId: string
  }

  export type ExceptionUpdateInput = {
    date?: StringFieldUpdateOperationsInput | string
    Slot?: SlotUpdateOneRequiredWithoutExceptionsNestedInput
  }

  export type ExceptionUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    date?: StringFieldUpdateOperationsInput | string
    slotId?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionCreateManyInput = {
    id?: number
    date: string
    slotId: string
  }

  export type ExceptionUpdateManyMutationInput = {
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    date?: StringFieldUpdateOperationsInput | string
    slotId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatCreateInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    client: UserCreateNestedOneWithoutChatInput
    expert: ExpertCreateNestedOneWithoutChatInput
    messages?: ChatMessageCreateNestedManyWithoutChatInput
  }

  export type ChatUncheckedCreateInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    clientId: string
    expertId: string
    messages?: ChatMessageUncheckedCreateNestedManyWithoutChatInput
  }

  export type ChatUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    client?: UserUpdateOneRequiredWithoutChatNestedInput
    expert?: ExpertUpdateOneRequiredWithoutChatNestedInput
    messages?: ChatMessageUpdateManyWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    messages?: ChatMessageUncheckedUpdateManyWithoutChatNestedInput
  }

  export type ChatCreateManyInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    clientId: string
    expertId: string
  }

  export type ChatUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ChatUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatMessageCreateInput = {
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chat: ChatCreateNestedOneWithoutMessagesInput
    Expert?: ExpertCreateNestedOneWithoutChatMessageInput
    sender: UserCreateNestedOneWithoutMessagesInput
  }

  export type ChatMessageUncheckedCreateInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    senderId: string
    expertId?: string | null
  }

  export type ChatMessageUpdateInput = {
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chat?: ChatUpdateOneRequiredWithoutMessagesNestedInput
    Expert?: ExpertUpdateOneWithoutChatMessageNestedInput
    sender?: UserUpdateOneRequiredWithoutMessagesNestedInput
  }

  export type ChatMessageUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatMessageCreateManyInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    senderId: string
    expertId?: string | null
  }

  export type ChatMessageUpdateManyMutationInput = {
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ChatMessageUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClientReviewCreateInput = {
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutReceivedClientReviewsInput
    client: UserCreateNestedOneWithoutReceivedClientReviewsInput
    expert: ExpertCreateNestedOneWithoutClientReviewInput
  }

  export type ClientReviewUncheckedCreateInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
    expertId: string
  }

  export type ClientReviewUpdateInput = {
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
    client?: UserUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutClientReviewNestedInput
  }

  export type ClientReviewUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ClientReviewCreateManyInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
    expertId: string
  }

  export type ClientReviewUpdateManyMutationInput = {
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ClientReviewUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertReviewCreateInput = {
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutWrittenExpertReviewsInput
    client: UserCreateNestedOneWithoutWrittenExpertReviewsInput
    expert: ExpertCreateNestedOneWithoutExpertReviewInput
  }

  export type ExpertReviewUncheckedCreateInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    expertId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ExpertReviewUpdateInput = {
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
    client?: UserUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutExpertReviewNestedInput
  }

  export type ExpertReviewUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertReviewCreateManyInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    expertId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ExpertReviewUpdateManyMutationInput = {
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ExpertReviewUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type admin_invite_expertsCreateInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    created_at?: Date | string
    email?: string | null
    status?: $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsUncheckedCreateInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    created_at?: Date | string
    email?: string | null
    status?: $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumINVITE_STATUSFieldUpdateOperationsInput | $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumINVITE_STATUSFieldUpdateOperationsInput | $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsCreateManyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    created_at?: Date | string
    email?: string | null
    status?: $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumINVITE_STATUSFieldUpdateOperationsInput | $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumINVITE_STATUSFieldUpdateOperationsInput | $Enums.INVITE_STATUS
  }

  export type admin_mbc_cmsCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    section1_text?: string | null
    section1_image?: string | null
    section2_text?: string | null
    section2_image?: string | null
    about_us_title?: string | null
    about_us_desc?: string | null
    general_condition_of_use?: string | null
    general_condition_of_sales?: string | null
    is_active?: number | null
    invite_email_content?: string | null
    invite_email_subject?: string | null
  }

  export type admin_mbc_cmsUncheckedCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    section1_text?: string | null
    section1_image?: string | null
    section2_text?: string | null
    section2_image?: string | null
    about_us_title?: string | null
    about_us_desc?: string | null
    general_condition_of_use?: string | null
    general_condition_of_sales?: string | null
    is_active?: number | null
    invite_email_content?: string | null
    invite_email_subject?: string | null
  }

  export type admin_mbc_cmsUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    section1_text?: NullableStringFieldUpdateOperationsInput | string | null
    section1_image?: NullableStringFieldUpdateOperationsInput | string | null
    section2_text?: NullableStringFieldUpdateOperationsInput | string | null
    section2_image?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_title?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_desc?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_use?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_sales?: NullableStringFieldUpdateOperationsInput | string | null
    is_active?: NullableIntFieldUpdateOperationsInput | number | null
    invite_email_content?: NullableStringFieldUpdateOperationsInput | string | null
    invite_email_subject?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_cmsUncheckedUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    section1_text?: NullableStringFieldUpdateOperationsInput | string | null
    section1_image?: NullableStringFieldUpdateOperationsInput | string | null
    section2_text?: NullableStringFieldUpdateOperationsInput | string | null
    section2_image?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_title?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_desc?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_use?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_sales?: NullableStringFieldUpdateOperationsInput | string | null
    is_active?: NullableIntFieldUpdateOperationsInput | number | null
    invite_email_content?: NullableStringFieldUpdateOperationsInput | string | null
    invite_email_subject?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_cmsCreateManyInput = {
    id?: bigint | number
    created_at?: Date | string
    section1_text?: string | null
    section1_image?: string | null
    section2_text?: string | null
    section2_image?: string | null
    about_us_title?: string | null
    about_us_desc?: string | null
    general_condition_of_use?: string | null
    general_condition_of_sales?: string | null
    is_active?: number | null
    invite_email_content?: string | null
    invite_email_subject?: string | null
  }

  export type admin_mbc_cmsUpdateManyMutationInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    section1_text?: NullableStringFieldUpdateOperationsInput | string | null
    section1_image?: NullableStringFieldUpdateOperationsInput | string | null
    section2_text?: NullableStringFieldUpdateOperationsInput | string | null
    section2_image?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_title?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_desc?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_use?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_sales?: NullableStringFieldUpdateOperationsInput | string | null
    is_active?: NullableIntFieldUpdateOperationsInput | number | null
    invite_email_content?: NullableStringFieldUpdateOperationsInput | string | null
    invite_email_subject?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_cmsUncheckedUpdateManyInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    section1_text?: NullableStringFieldUpdateOperationsInput | string | null
    section1_image?: NullableStringFieldUpdateOperationsInput | string | null
    section2_text?: NullableStringFieldUpdateOperationsInput | string | null
    section2_image?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_title?: NullableStringFieldUpdateOperationsInput | string | null
    about_us_desc?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_use?: NullableStringFieldUpdateOperationsInput | string | null
    general_condition_of_sales?: NullableStringFieldUpdateOperationsInput | string | null
    is_active?: NullableIntFieldUpdateOperationsInput | number | null
    invite_email_content?: NullableStringFieldUpdateOperationsInput | string | null
    invite_email_subject?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_faqsCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    question_title?: string | null
    question_desc?: string | null
  }

  export type admin_mbc_faqsUncheckedCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    question_title?: string | null
    question_desc?: string | null
  }

  export type admin_mbc_faqsUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    question_title?: NullableStringFieldUpdateOperationsInput | string | null
    question_desc?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_faqsUncheckedUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    question_title?: NullableStringFieldUpdateOperationsInput | string | null
    question_desc?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_faqsCreateManyInput = {
    id?: bigint | number
    created_at?: Date | string
    question_title?: string | null
    question_desc?: string | null
  }

  export type admin_mbc_faqsUpdateManyMutationInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    question_title?: NullableStringFieldUpdateOperationsInput | string | null
    question_desc?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_mbc_faqsUncheckedUpdateManyInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    question_title?: NullableStringFieldUpdateOperationsInput | string | null
    question_desc?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_newsletterCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    email?: string | null
    isUser: boolean
    name?: string | null
  }

  export type admin_newsletterUncheckedCreateInput = {
    id?: bigint | number
    created_at?: Date | string
    email?: string | null
    isUser: boolean
    name?: string | null
  }

  export type admin_newsletterUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    isUser?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_newsletterUncheckedUpdateInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    isUser?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_newsletterCreateManyInput = {
    id?: bigint | number
    created_at?: Date | string
    email?: string | null
    isUser: boolean
    name?: string | null
  }

  export type admin_newsletterUpdateManyMutationInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    isUser?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_newsletterUncheckedUpdateManyInput = {
    id?: BigIntFieldUpdateOperationsInput | bigint | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    isUser?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_userCreateInput = {
    id: string
    created_at?: Date | string
    role?: $Enums.AdminRole | null
    User: UserCreateNestedOneWithoutAdmin_userInput
  }

  export type admin_userUncheckedCreateInput = {
    id: string
    created_at?: Date | string
    role?: $Enums.AdminRole | null
    user_id: string
  }

  export type admin_userUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
    User?: UserUpdateOneRequiredWithoutAdmin_userNestedInput
  }

  export type admin_userUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
    user_id?: StringFieldUpdateOperationsInput | string
  }

  export type admin_userCreateManyInput = {
    id: string
    created_at?: Date | string
    role?: $Enums.AdminRole | null
    user_id: string
  }

  export type admin_userUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
  }

  export type admin_userUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
    user_id?: StringFieldUpdateOperationsInput | string
  }

  export type faqQuestionCreateInput = {
    question: string
    answer: string
    created_at?: Date | string
  }

  export type faqQuestionUncheckedCreateInput = {
    id?: number
    question: string
    answer: string
    created_at?: Date | string
  }

  export type faqQuestionUpdateInput = {
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type faqQuestionUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type faqQuestionCreateManyInput = {
    id?: number
    question: string
    answer: string
    created_at?: Date | string
  }

  export type faqQuestionUpdateManyMutationInput = {
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type faqQuestionUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionCreateInput = {
    id: string
    active_expires: bigint | number
    idle_expires: bigint | number
    User: UserCreateNestedOneWithoutSessionInput
  }

  export type sessionUncheckedCreateInput = {
    id: string
    user_id: string
    active_expires: bigint | number
    idle_expires: bigint | number
  }

  export type sessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    User?: UserUpdateOneRequiredWithoutSessionNestedInput
  }

  export type sessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type sessionCreateManyInput = {
    id: string
    user_id: string
    active_expires: bigint | number
    idle_expires: bigint | number
  }

  export type sessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type sessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type admin_editingCreateInput = {
    id?: number
    updatedAt: Date | string
    genericEmailBody?: string | null
    genericEmailHeader?: string | null
    aboutContent?: string | null
    aboutImageUrl?: string | null
    landingPageDesc?: string | null
    landingPageHeading?: string | null
    landingPageHero?: string | null
    landingPageSectionDesc?: string | null
    landingPageSectionHeading?: string | null
    landingPageSectionHero?: string | null
    conditionsSale?: string | null
    conditionsUse?: string | null
    privacyPolicy?: string | null
  }

  export type admin_editingUncheckedCreateInput = {
    id?: number
    updatedAt: Date | string
    genericEmailBody?: string | null
    genericEmailHeader?: string | null
    aboutContent?: string | null
    aboutImageUrl?: string | null
    landingPageDesc?: string | null
    landingPageHeading?: string | null
    landingPageHero?: string | null
    landingPageSectionDesc?: string | null
    landingPageSectionHeading?: string | null
    landingPageSectionHero?: string | null
    conditionsSale?: string | null
    conditionsUse?: string | null
    privacyPolicy?: string | null
  }

  export type admin_editingUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    genericEmailBody?: NullableStringFieldUpdateOperationsInput | string | null
    genericEmailHeader?: NullableStringFieldUpdateOperationsInput | string | null
    aboutContent?: NullableStringFieldUpdateOperationsInput | string | null
    aboutImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHero?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHero?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsSale?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsUse?: NullableStringFieldUpdateOperationsInput | string | null
    privacyPolicy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_editingUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    genericEmailBody?: NullableStringFieldUpdateOperationsInput | string | null
    genericEmailHeader?: NullableStringFieldUpdateOperationsInput | string | null
    aboutContent?: NullableStringFieldUpdateOperationsInput | string | null
    aboutImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHero?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHero?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsSale?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsUse?: NullableStringFieldUpdateOperationsInput | string | null
    privacyPolicy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_editingCreateManyInput = {
    id?: number
    updatedAt: Date | string
    genericEmailBody?: string | null
    genericEmailHeader?: string | null
    aboutContent?: string | null
    aboutImageUrl?: string | null
    landingPageDesc?: string | null
    landingPageHeading?: string | null
    landingPageHero?: string | null
    landingPageSectionDesc?: string | null
    landingPageSectionHeading?: string | null
    landingPageSectionHero?: string | null
    conditionsSale?: string | null
    conditionsUse?: string | null
    privacyPolicy?: string | null
  }

  export type admin_editingUpdateManyMutationInput = {
    id?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    genericEmailBody?: NullableStringFieldUpdateOperationsInput | string | null
    genericEmailHeader?: NullableStringFieldUpdateOperationsInput | string | null
    aboutContent?: NullableStringFieldUpdateOperationsInput | string | null
    aboutImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHero?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHero?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsSale?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsUse?: NullableStringFieldUpdateOperationsInput | string | null
    privacyPolicy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_editingUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    genericEmailBody?: NullableStringFieldUpdateOperationsInput | string | null
    genericEmailHeader?: NullableStringFieldUpdateOperationsInput | string | null
    aboutContent?: NullableStringFieldUpdateOperationsInput | string | null
    aboutImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageHero?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionDesc?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHeading?: NullableStringFieldUpdateOperationsInput | string | null
    landingPageSectionHero?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsSale?: NullableStringFieldUpdateOperationsInput | string | null
    conditionsUse?: NullableStringFieldUpdateOperationsInput | string | null
    privacyPolicy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_notificationCreateInput = {
    created_at?: Date | string
    title: string
    link?: string | null
    description: string
  }

  export type admin_notificationUncheckedCreateInput = {
    id?: number
    created_at?: Date | string
    title: string
    link?: string | null
    description: string
  }

  export type admin_notificationUpdateInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    link?: NullableStringFieldUpdateOperationsInput | string | null
    description?: StringFieldUpdateOperationsInput | string
  }

  export type admin_notificationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    link?: NullableStringFieldUpdateOperationsInput | string | null
    description?: StringFieldUpdateOperationsInput | string
  }

  export type admin_notificationCreateManyInput = {
    id?: number
    created_at?: Date | string
    title: string
    link?: string | null
    description: string
  }

  export type admin_notificationUpdateManyMutationInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    link?: NullableStringFieldUpdateOperationsInput | string | null
    description?: StringFieldUpdateOperationsInput | string
  }

  export type admin_notificationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    link?: NullableStringFieldUpdateOperationsInput | string | null
    description?: StringFieldUpdateOperationsInput | string
  }

  export type admin_notification_statusCreateInput = {
    id?: number
    status?: $Enums.NotificationStatus
    newExpertApplication?: $Enums.NotificationStatus
    newInvitationAccepted?: $Enums.NotificationStatus
    newIdVerification?: $Enums.NotificationStatus
  }

  export type admin_notification_statusUncheckedCreateInput = {
    id?: number
    status?: $Enums.NotificationStatus
    newExpertApplication?: $Enums.NotificationStatus
    newInvitationAccepted?: $Enums.NotificationStatus
    newIdVerification?: $Enums.NotificationStatus
  }

  export type admin_notification_statusUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
  }

  export type admin_notification_statusUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
  }

  export type admin_notification_statusCreateManyInput = {
    id?: number
    status?: $Enums.NotificationStatus
    newExpertApplication?: $Enums.NotificationStatus
    newInvitationAccepted?: $Enums.NotificationStatus
    newIdVerification?: $Enums.NotificationStatus
  }

  export type admin_notification_statusUpdateManyMutationInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
  }

  export type admin_notification_statusUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newExpertApplication?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newInvitationAccepted?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
    newIdVerification?: EnumNotificationStatusFieldUpdateOperationsInput | $Enums.NotificationStatus
  }

  export type expertApplicationAnswerCreateInput = {
    id?: string
    answer: string
    created_at?: Date | string
    admin_expert_application?: admin_expert_applicationCreateNestedOneWithoutAnswerInput
    expertApplicationQuestion: expertApplicationQuestionCreateNestedOneWithoutExpertApplicationAnswerInput
    User: UserCreateNestedOneWithoutExpertApplicationAnswerInput
  }

  export type expertApplicationAnswerUncheckedCreateInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    questionId: string
    admin_expert_applicationId?: string | null
  }

  export type expertApplicationAnswerUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    admin_expert_application?: admin_expert_applicationUpdateOneWithoutAnswerNestedInput
    expertApplicationQuestion?: expertApplicationQuestionUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
    User?: UserUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
  }

  export type expertApplicationAnswerUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    questionId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type expertApplicationAnswerCreateManyInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    questionId: string
    admin_expert_applicationId?: string | null
  }

  export type expertApplicationAnswerUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type expertApplicationAnswerUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    questionId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type admin_expert_applicationCreateInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    User: UserCreateNestedOneWithoutAdmin_expert_applicationInput
    answer?: expertApplicationAnswerCreateNestedManyWithoutAdmin_expert_applicationInput
  }

  export type admin_expert_applicationUncheckedCreateInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    userId: string
    answer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutAdmin_expert_applicationInput
  }

  export type admin_expert_applicationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutAdmin_expert_applicationNestedInput
    answer?: expertApplicationAnswerUpdateManyWithoutAdmin_expert_applicationNestedInput
  }

  export type admin_expert_applicationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    answer?: expertApplicationAnswerUncheckedUpdateManyWithoutAdmin_expert_applicationNestedInput
  }

  export type admin_expert_applicationCreateManyInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    userId: string
  }

  export type admin_expert_applicationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type admin_expert_applicationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type expertApplicationQuestionCreateInput = {
    id: string
    question: string
    created_at?: Date | string
    order?: number
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutExpertApplicationQuestionInput
  }

  export type expertApplicationQuestionUncheckedCreateInput = {
    id: string
    question: string
    created_at?: Date | string
    order?: number
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutExpertApplicationQuestionInput
  }

  export type expertApplicationQuestionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutExpertApplicationQuestionNestedInput
  }

  export type expertApplicationQuestionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutExpertApplicationQuestionNestedInput
  }

  export type expertApplicationQuestionCreateManyInput = {
    id: string
    question: string
    created_at?: Date | string
    order?: number
  }

  export type expertApplicationQuestionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
  }

  export type expertApplicationQuestionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    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 BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type StringNullableListFilter<$PrismaModel = never> = {
    equals?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    has?: string | StringFieldRefInput<$PrismaModel> | null
    hasEvery?: string[] | ListStringFieldRefInput<$PrismaModel>
    hasSome?: string[] | ListStringFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }
  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[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type EnumCountryCodeFilter<$PrismaModel = never> = {
    equals?: $Enums.CountryCode | EnumCountryCodeFieldRefInput<$PrismaModel>
    in?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    notIn?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    not?: NestedEnumCountryCodeFilter<$PrismaModel> | $Enums.CountryCode
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | 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 AppointmentListRelationFilter = {
    every?: AppointmentWhereInput
    some?: AppointmentWhereInput
    none?: AppointmentWhereInput
  }

  export type AvailabilityListRelationFilter = {
    every?: AvailabilityWhereInput
    some?: AvailabilityWhereInput
    none?: AvailabilityWhereInput
  }

  export type ChatListRelationFilter = {
    every?: ChatWhereInput
    some?: ChatWhereInput
    none?: ChatWhereInput
  }

  export type ChatMessageListRelationFilter = {
    every?: ChatMessageWhereInput
    some?: ChatMessageWhereInput
    none?: ChatMessageWhereInput
  }

  export type ClientReviewListRelationFilter = {
    every?: ClientReviewWhereInput
    some?: ClientReviewWhereInput
    none?: ClientReviewWhereInput
  }

  export type EducationListRelationFilter = {
    every?: EducationWhereInput
    some?: EducationWhereInput
    none?: EducationWhereInput
  }

  export type ExperienceListRelationFilter = {
    every?: ExperienceWhereInput
    some?: ExperienceWhereInput
    none?: ExperienceWhereInput
  }

  export type ExpertNullableRelationFilter = {
    is?: ExpertWhereInput | null
    isNot?: ExpertWhereInput | null
  }

  export type ExpertReviewListRelationFilter = {
    every?: ExpertReviewWhereInput
    some?: ExpertReviewWhereInput
    none?: ExpertReviewWhereInput
  }

  export type ExpertiseListRelationFilter = {
    every?: ExpertiseWhereInput
    some?: ExpertiseWhereInput
    none?: ExpertiseWhereInput
  }

  export type KeyListRelationFilter = {
    every?: KeyWhereInput
    some?: KeyWhereInput
    none?: KeyWhereInput
  }

  export type LanguageListRelationFilter = {
    every?: LanguageWhereInput
    some?: LanguageWhereInput
    none?: LanguageWhereInput
  }

  export type QuestionListRelationFilter = {
    every?: QuestionWhereInput
    some?: QuestionWhereInput
    none?: QuestionWhereInput
  }

  export type ReplyListRelationFilter = {
    every?: ReplyWhereInput
    some?: ReplyWhereInput
    none?: ReplyWhereInput
  }

  export type Admin_expert_applicationListRelationFilter = {
    every?: admin_expert_applicationWhereInput
    some?: admin_expert_applicationWhereInput
    none?: admin_expert_applicationWhereInput
  }

  export type Admin_userNullableRelationFilter = {
    is?: admin_userWhereInput | null
    isNot?: admin_userWhereInput | null
  }

  export type Email_verification_tokenListRelationFilter = {
    every?: email_verification_tokenWhereInput
    some?: email_verification_tokenWhereInput
    none?: email_verification_tokenWhereInput
  }

  export type ExpertApplicationAnswerListRelationFilter = {
    every?: expertApplicationAnswerWhereInput
    some?: expertApplicationAnswerWhereInput
    none?: expertApplicationAnswerWhereInput
  }

  export type Id_verificationListRelationFilter = {
    every?: id_verificationWhereInput
    some?: id_verificationWhereInput
    none?: id_verificationWhereInput
  }

  export type SessionListRelationFilter = {
    every?: sessionWhereInput
    some?: sessionWhereInput
    none?: sessionWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AppointmentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AvailabilityOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ChatOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ChatMessageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ClientReviewOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type EducationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ExperienceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ExpertReviewOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ExpertiseOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type KeyOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type LanguageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type QuestionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ReplyOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type admin_expert_applicationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type email_verification_tokenOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type expertApplicationAnswerOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type id_verificationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type sessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    imageUrl?: SortOrder
    imageName?: SortOrder
    customer_id?: SortOrder
    phone?: SortOrder
    follower?: SortOrder
    role?: SortOrder
    state?: SortOrder
    city?: SortOrder
    zipcode?: SortOrder
    timezone?: SortOrder
    rate?: SortOrder
    countryOfResidence?: SortOrder
    biography?: SortOrder
    linkedInURL?: SortOrder
    instagramURL?: SortOrder
    youtubeURL?: SortOrder
    spotifyURL?: SortOrder
    tiktokURL?: SortOrder
    twitterURL?: SortOrder
    amazonURL?: SortOrder
    websiteURL1?: SortOrder
    websiteURL2?: SortOrder
    createdAt?: SortOrder
    refresh_token?: SortOrder
    isExpert?: SortOrder
    videos?: SortOrder
    expertId?: SortOrder
    provider?: SortOrder
    otherInfo?: SortOrder
    is_invited?: SortOrder
    userName?: SortOrder
    isBanned?: SortOrder
    isAdmin?: SortOrder
    isSubscribed?: SortOrder
    countryOfResidenceISO?: SortOrder
    countryOfResidenceId?: SortOrder
    dateOfBirth?: SortOrder
    emailVerified?: SortOrder
    idVerified?: SortOrder
    FavoriteExpertIds?: SortOrder
  }

  export type UserAvgOrderByAggregateInput = {
    follower?: SortOrder
    is_invited?: SortOrder
    countryOfResidenceId?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    imageUrl?: SortOrder
    imageName?: SortOrder
    customer_id?: SortOrder
    phone?: SortOrder
    follower?: SortOrder
    role?: SortOrder
    state?: SortOrder
    city?: SortOrder
    zipcode?: SortOrder
    timezone?: SortOrder
    rate?: SortOrder
    countryOfResidence?: SortOrder
    biography?: SortOrder
    linkedInURL?: SortOrder
    instagramURL?: SortOrder
    youtubeURL?: SortOrder
    spotifyURL?: SortOrder
    tiktokURL?: SortOrder
    twitterURL?: SortOrder
    amazonURL?: SortOrder
    websiteURL1?: SortOrder
    websiteURL2?: SortOrder
    createdAt?: SortOrder
    refresh_token?: SortOrder
    isExpert?: SortOrder
    expertId?: SortOrder
    provider?: SortOrder
    is_invited?: SortOrder
    userName?: SortOrder
    isBanned?: SortOrder
    isAdmin?: SortOrder
    isSubscribed?: SortOrder
    countryOfResidenceISO?: SortOrder
    countryOfResidenceId?: SortOrder
    dateOfBirth?: SortOrder
    emailVerified?: SortOrder
    idVerified?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    imageUrl?: SortOrder
    imageName?: SortOrder
    customer_id?: SortOrder
    phone?: SortOrder
    follower?: SortOrder
    role?: SortOrder
    state?: SortOrder
    city?: SortOrder
    zipcode?: SortOrder
    timezone?: SortOrder
    rate?: SortOrder
    countryOfResidence?: SortOrder
    biography?: SortOrder
    linkedInURL?: SortOrder
    instagramURL?: SortOrder
    youtubeURL?: SortOrder
    spotifyURL?: SortOrder
    tiktokURL?: SortOrder
    twitterURL?: SortOrder
    amazonURL?: SortOrder
    websiteURL1?: SortOrder
    websiteURL2?: SortOrder
    createdAt?: SortOrder
    refresh_token?: SortOrder
    isExpert?: SortOrder
    expertId?: SortOrder
    provider?: SortOrder
    is_invited?: SortOrder
    userName?: SortOrder
    isBanned?: SortOrder
    isAdmin?: SortOrder
    isSubscribed?: SortOrder
    countryOfResidenceISO?: SortOrder
    countryOfResidenceId?: SortOrder
    dateOfBirth?: SortOrder
    emailVerified?: SortOrder
    idVerified?: SortOrder
  }

  export type UserSumOrderByAggregateInput = {
    follower?: SortOrder
    is_invited?: SortOrder
    countryOfResidenceId?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    mode?: QueryMode
    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[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | 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 DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    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 BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }
  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[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type EnumCountryCodeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CountryCode | EnumCountryCodeFieldRefInput<$PrismaModel>
    in?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    notIn?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    not?: NestedEnumCountryCodeWithAggregatesFilter<$PrismaModel> | $Enums.CountryCode
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCountryCodeFilter<$PrismaModel>
    _max?: NestedEnumCountryCodeFilter<$PrismaModel>
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | 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 UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type StripeAccountNullableRelationFilter = {
    is?: StripeAccountWhereInput | null
    isNot?: StripeAccountWhereInput | null
  }

  export type ExpertCountOrderByAggregateInput = {
    id?: SortOrder
    stripeAccountId?: SortOrder
    rate?: SortOrder
    timezone?: SortOrder
    user_id?: SortOrder
    isAccepted?: SortOrder
    countryOfResidenceId?: SortOrder
    created_at?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
  }

  export type ExpertAvgOrderByAggregateInput = {
    stripeAccountId?: SortOrder
    countryOfResidenceId?: SortOrder
  }

  export type ExpertMaxOrderByAggregateInput = {
    id?: SortOrder
    stripeAccountId?: SortOrder
    rate?: SortOrder
    timezone?: SortOrder
    user_id?: SortOrder
    isAccepted?: SortOrder
    countryOfResidenceId?: SortOrder
    created_at?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
  }

  export type ExpertMinOrderByAggregateInput = {
    id?: SortOrder
    stripeAccountId?: SortOrder
    rate?: SortOrder
    timezone?: SortOrder
    user_id?: SortOrder
    isAccepted?: SortOrder
    countryOfResidenceId?: SortOrder
    created_at?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
  }

  export type ExpertSumOrderByAggregateInput = {
    stripeAccountId?: SortOrder
    countryOfResidenceId?: SortOrder
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type EnumStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.Status | EnumStatusFieldRefInput<$PrismaModel>
    in?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStatusFilter<$PrismaModel> | $Enums.Status
  }

  export type EnumdocumentTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.documentType | EnumdocumentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumdocumentTypeFilter<$PrismaModel> | $Enums.documentType
  }

  export type id_verificationCountOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    idImageUrlBack?: SortOrder
    idImageUrlFront?: SortOrder
    createdAt?: SortOrder
    documentType?: SortOrder
  }

  export type id_verificationAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type id_verificationMaxOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    idImageUrlBack?: SortOrder
    idImageUrlFront?: SortOrder
    createdAt?: SortOrder
    documentType?: SortOrder
  }

  export type id_verificationMinOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    idImageUrlBack?: SortOrder
    idImageUrlFront?: SortOrder
    createdAt?: SortOrder
    documentType?: SortOrder
  }

  export type id_verificationSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    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 EnumStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Status | EnumStatusFieldRefInput<$PrismaModel>
    in?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStatusWithAggregatesFilter<$PrismaModel> | $Enums.Status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusFilter<$PrismaModel>
    _max?: NestedEnumStatusFilter<$PrismaModel>
  }

  export type EnumdocumentTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.documentType | EnumdocumentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumdocumentTypeWithAggregatesFilter<$PrismaModel> | $Enums.documentType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumdocumentTypeFilter<$PrismaModel>
    _max?: NestedEnumdocumentTypeFilter<$PrismaModel>
  }

  export type BigIntFilter<$PrismaModel = never> = {
    equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    not?: NestedBigIntFilter<$PrismaModel> | bigint | number
  }

  export type email_verification_tokenCountOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    userId?: SortOrder
  }

  export type email_verification_tokenAvgOrderByAggregateInput = {
    expires?: SortOrder
  }

  export type email_verification_tokenMaxOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    userId?: SortOrder
  }

  export type email_verification_tokenMinOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    userId?: SortOrder
  }

  export type email_verification_tokenSumOrderByAggregateInput = {
    expires?: SortOrder
  }

  export type BigIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    not?: NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedBigIntFilter<$PrismaModel>
    _min?: NestedBigIntFilter<$PrismaModel>
    _max?: NestedBigIntFilter<$PrismaModel>
  }

  export type QuestionCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
  }

  export type QuestionAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type QuestionMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
  }

  export type QuestionMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
  }

  export type QuestionSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type AppointmentRelationFilter = {
    is?: AppointmentWhereInput
    isNot?: AppointmentWhereInput
  }

  export type ReplyCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    appointmentKey?: SortOrder
    questionContent?: SortOrder
    userId?: SortOrder
  }

  export type ReplyAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ReplyMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    appointmentKey?: SortOrder
    questionContent?: SortOrder
    userId?: SortOrder
  }

  export type ReplyMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    appointmentKey?: SortOrder
    questionContent?: SortOrder
    userId?: SortOrder
  }

  export type ReplySumOrderByAggregateInput = {
    id?: SortOrder
  }
  export type JsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>

  export type JsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type ExpertRelationFilter = {
    is?: ExpertWhereInput
    isNot?: ExpertWhereInput
  }

  export type StripeAccountCountOrderByAggregateInput = {
    id?: SortOrder
    stripeData?: SortOrder
    expertId?: SortOrder
  }

  export type StripeAccountAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type StripeAccountMaxOrderByAggregateInput = {
    id?: SortOrder
    expertId?: SortOrder
  }

  export type StripeAccountMinOrderByAggregateInput = {
    id?: SortOrder
    expertId?: SortOrder
  }

  export type StripeAccountSumOrderByAggregateInput = {
    id?: SortOrder
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type KeyCountOrderByAggregateInput = {
    id?: SortOrder
    hashed_password?: SortOrder
    user_id?: SortOrder
  }

  export type KeyMaxOrderByAggregateInput = {
    id?: SortOrder
    hashed_password?: SortOrder
    user_id?: SortOrder
  }

  export type KeyMinOrderByAggregateInput = {
    id?: SortOrder
    hashed_password?: SortOrder
    user_id?: SortOrder
  }

  export type ExperienceCountOrderByAggregateInput = {
    id?: SortOrder
    companyName?: SortOrder
    role?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    description?: SortOrder
    userId?: SortOrder
    endDate?: SortOrder
    startDate?: SortOrder
  }

  export type ExperienceAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExperienceMaxOrderByAggregateInput = {
    id?: SortOrder
    companyName?: SortOrder
    role?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    description?: SortOrder
    userId?: SortOrder
    endDate?: SortOrder
    startDate?: SortOrder
  }

  export type ExperienceMinOrderByAggregateInput = {
    id?: SortOrder
    companyName?: SortOrder
    role?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    description?: SortOrder
    userId?: SortOrder
    endDate?: SortOrder
    startDate?: SortOrder
  }

  export type ExperienceSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EducationCountOrderByAggregateInput = {
    id?: SortOrder
    institutionName?: SortOrder
    diplomaTitle?: SortOrder
    fieldOfStudy?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type EducationAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EducationMaxOrderByAggregateInput = {
    id?: SortOrder
    institutionName?: SortOrder
    diplomaTitle?: SortOrder
    fieldOfStudy?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type EducationMinOrderByAggregateInput = {
    id?: SortOrder
    institutionName?: SortOrder
    diplomaTitle?: SortOrder
    fieldOfStudy?: SortOrder
    isCurrent?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type EducationSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExpertiseCountOrderByAggregateInput = {
    id?: SortOrder
    field?: SortOrder
    isCurrent?: SortOrder
    description?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type ExpertiseAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExpertiseMaxOrderByAggregateInput = {
    id?: SortOrder
    field?: SortOrder
    isCurrent?: SortOrder
    description?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type ExpertiseMinOrderByAggregateInput = {
    id?: SortOrder
    field?: SortOrder
    isCurrent?: SortOrder
    description?: SortOrder
    duration?: SortOrder
    userId?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
  }

  export type ExpertiseSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type LanguageCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type LanguageAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type LanguageMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type LanguageMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type LanguageSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ClientReviewNullableRelationFilter = {
    is?: ClientReviewWhereInput | null
    isNot?: ClientReviewWhereInput | null
  }

  export type ExpertReviewNullableRelationFilter = {
    is?: ExpertReviewWhereInput | null
    isNot?: ExpertReviewWhereInput | null
  }

  export type AppointmentCountOrderByAggregateInput = {
    id?: SortOrder
    clientId?: SortOrder
    clientEmail?: SortOrder
    expertId?: SortOrder
    clientName?: SortOrder
    expertName?: SortOrder
    isAcceptedByExpert?: SortOrder
    price?: SortOrder
    timezone?: SortOrder
    date?: SortOrder
    dayName?: SortOrder
    time?: SortOrder
    text?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    paymentStatus?: SortOrder
    paymentIntentId?: SortOrder
    sessionId?: SortOrder
    authorizedDate?: SortOrder
    appointementKeyInExpertTimeZone?: SortOrder
    appointementKeyInClientTimeZone?: SortOrder
    bookedAppointments?: SortOrder
    status?: SortOrder
    reason?: SortOrder
  }

  export type AppointmentAvgOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
  }

  export type AppointmentMaxOrderByAggregateInput = {
    id?: SortOrder
    clientId?: SortOrder
    clientEmail?: SortOrder
    expertId?: SortOrder
    clientName?: SortOrder
    expertName?: SortOrder
    isAcceptedByExpert?: SortOrder
    price?: SortOrder
    timezone?: SortOrder
    date?: SortOrder
    dayName?: SortOrder
    time?: SortOrder
    text?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    paymentStatus?: SortOrder
    paymentIntentId?: SortOrder
    sessionId?: SortOrder
    authorizedDate?: SortOrder
    appointementKeyInExpertTimeZone?: SortOrder
    appointementKeyInClientTimeZone?: SortOrder
    status?: SortOrder
    reason?: SortOrder
  }

  export type AppointmentMinOrderByAggregateInput = {
    id?: SortOrder
    clientId?: SortOrder
    clientEmail?: SortOrder
    expertId?: SortOrder
    clientName?: SortOrder
    expertName?: SortOrder
    isAcceptedByExpert?: SortOrder
    price?: SortOrder
    timezone?: SortOrder
    date?: SortOrder
    dayName?: SortOrder
    time?: SortOrder
    text?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    paymentStatus?: SortOrder
    paymentIntentId?: SortOrder
    sessionId?: SortOrder
    authorizedDate?: SortOrder
    appointementKeyInExpertTimeZone?: SortOrder
    appointementKeyInClientTimeZone?: SortOrder
    status?: SortOrder
    reason?: SortOrder
  }

  export type AppointmentSumOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
  }

  export type UserNullableRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type SlotListRelationFilter = {
    every?: SlotWhereInput
    some?: SlotWhereInput
    none?: SlotWhereInput
  }

  export type SlotOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AvailabilityCountOrderByAggregateInput = {
    id?: SortOrder
    day?: SortOrder
    timezone?: SortOrder
    expertId?: SortOrder
    userId?: SortOrder
  }

  export type AvailabilityAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type AvailabilityMaxOrderByAggregateInput = {
    id?: SortOrder
    day?: SortOrder
    timezone?: SortOrder
    expertId?: SortOrder
    userId?: SortOrder
  }

  export type AvailabilityMinOrderByAggregateInput = {
    id?: SortOrder
    day?: SortOrder
    timezone?: SortOrder
    expertId?: SortOrder
    userId?: SortOrder
  }

  export type AvailabilitySumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExceptionListRelationFilter = {
    every?: ExceptionWhereInput
    some?: ExceptionWhereInput
    none?: ExceptionWhereInput
  }

  export type AvailabilityRelationFilter = {
    is?: AvailabilityWhereInput
    isNot?: AvailabilityWhereInput
  }

  export type ExceptionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SlotCountOrderByAggregateInput = {
    id?: SortOrder
    start?: SortOrder
    end?: SortOrder
    recurring?: SortOrder
    availabilityId?: SortOrder
    hide?: SortOrder
    isSplit?: SortOrder
    originalId?: SortOrder
  }

  export type SlotAvgOrderByAggregateInput = {
    availabilityId?: SortOrder
  }

  export type SlotMaxOrderByAggregateInput = {
    id?: SortOrder
    start?: SortOrder
    end?: SortOrder
    recurring?: SortOrder
    availabilityId?: SortOrder
    hide?: SortOrder
    isSplit?: SortOrder
    originalId?: SortOrder
  }

  export type SlotMinOrderByAggregateInput = {
    id?: SortOrder
    start?: SortOrder
    end?: SortOrder
    recurring?: SortOrder
    availabilityId?: SortOrder
    hide?: SortOrder
    isSplit?: SortOrder
    originalId?: SortOrder
  }

  export type SlotSumOrderByAggregateInput = {
    availabilityId?: SortOrder
  }

  export type SlotRelationFilter = {
    is?: SlotWhereInput
    isNot?: SlotWhereInput
  }

  export type ExceptionCountOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    slotId?: SortOrder
  }

  export type ExceptionAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExceptionMaxOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    slotId?: SortOrder
  }

  export type ExceptionMinOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    slotId?: SortOrder
  }

  export type ExceptionSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChatCountOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatMaxOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatMinOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatRelationFilter = {
    is?: ChatWhereInput
    isNot?: ChatWhereInput
  }

  export type ChatMessageCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    fileName?: SortOrder
    type?: SortOrder
    fileType?: SortOrder
    fileUrl?: SortOrder
    createdAt?: SortOrder
    chatId?: SortOrder
    senderId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatMessageAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChatMessageMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    fileName?: SortOrder
    type?: SortOrder
    fileType?: SortOrder
    fileUrl?: SortOrder
    createdAt?: SortOrder
    chatId?: SortOrder
    senderId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatMessageMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    fileName?: SortOrder
    type?: SortOrder
    fileType?: SortOrder
    fileUrl?: SortOrder
    createdAt?: SortOrder
    chatId?: SortOrder
    senderId?: SortOrder
    expertId?: SortOrder
  }

  export type ChatMessageSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ClientReviewCountOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ClientReviewAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ClientReviewMaxOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ClientReviewMinOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
    expertId?: SortOrder
  }

  export type ClientReviewSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExpertReviewCountOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    expertId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
  }

  export type ExpertReviewAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ExpertReviewMaxOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    expertId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
  }

  export type ExpertReviewMinOrderByAggregateInput = {
    id?: SortOrder
    reviewText?: SortOrder
    createdAt?: SortOrder
    videoRoomId?: SortOrder
    expertId?: SortOrder
    appointmentKey?: SortOrder
    isDisplayed?: SortOrder
    clientId?: SortOrder
  }

  export type ExpertReviewSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EnumINVITE_STATUSFilter<$PrismaModel = never> = {
    equals?: $Enums.INVITE_STATUS | EnumINVITE_STATUSFieldRefInput<$PrismaModel>
    in?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    notIn?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    not?: NestedEnumINVITE_STATUSFilter<$PrismaModel> | $Enums.INVITE_STATUS
  }

  export type admin_invite_expertsCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    status?: SortOrder
  }

  export type admin_invite_expertsMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    status?: SortOrder
  }

  export type admin_invite_expertsMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    status?: SortOrder
  }

  export type EnumINVITE_STATUSWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.INVITE_STATUS | EnumINVITE_STATUSFieldRefInput<$PrismaModel>
    in?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    notIn?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    not?: NestedEnumINVITE_STATUSWithAggregatesFilter<$PrismaModel> | $Enums.INVITE_STATUS
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumINVITE_STATUSFilter<$PrismaModel>
    _max?: NestedEnumINVITE_STATUSFilter<$PrismaModel>
  }

  export type admin_mbc_cmsCountOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    section1_text?: SortOrder
    section1_image?: SortOrder
    section2_text?: SortOrder
    section2_image?: SortOrder
    about_us_title?: SortOrder
    about_us_desc?: SortOrder
    general_condition_of_use?: SortOrder
    general_condition_of_sales?: SortOrder
    is_active?: SortOrder
    invite_email_content?: SortOrder
    invite_email_subject?: SortOrder
  }

  export type admin_mbc_cmsAvgOrderByAggregateInput = {
    id?: SortOrder
    is_active?: SortOrder
  }

  export type admin_mbc_cmsMaxOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    section1_text?: SortOrder
    section1_image?: SortOrder
    section2_text?: SortOrder
    section2_image?: SortOrder
    about_us_title?: SortOrder
    about_us_desc?: SortOrder
    general_condition_of_use?: SortOrder
    general_condition_of_sales?: SortOrder
    is_active?: SortOrder
    invite_email_content?: SortOrder
    invite_email_subject?: SortOrder
  }

  export type admin_mbc_cmsMinOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    section1_text?: SortOrder
    section1_image?: SortOrder
    section2_text?: SortOrder
    section2_image?: SortOrder
    about_us_title?: SortOrder
    about_us_desc?: SortOrder
    general_condition_of_use?: SortOrder
    general_condition_of_sales?: SortOrder
    is_active?: SortOrder
    invite_email_content?: SortOrder
    invite_email_subject?: SortOrder
  }

  export type admin_mbc_cmsSumOrderByAggregateInput = {
    id?: SortOrder
    is_active?: SortOrder
  }

  export type admin_mbc_faqsCountOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    question_title?: SortOrder
    question_desc?: SortOrder
  }

  export type admin_mbc_faqsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_mbc_faqsMaxOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    question_title?: SortOrder
    question_desc?: SortOrder
  }

  export type admin_mbc_faqsMinOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    question_title?: SortOrder
    question_desc?: SortOrder
  }

  export type admin_mbc_faqsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_newsletterCountOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    isUser?: SortOrder
    name?: SortOrder
  }

  export type admin_newsletterAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_newsletterMaxOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    isUser?: SortOrder
    name?: SortOrder
  }

  export type admin_newsletterMinOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    email?: SortOrder
    isUser?: SortOrder
    name?: SortOrder
  }

  export type admin_newsletterSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EnumAdminRoleNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAdminRoleNullableFilter<$PrismaModel> | $Enums.AdminRole | null
  }

  export type admin_userCountOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    role?: SortOrder
    user_id?: SortOrder
  }

  export type admin_userMaxOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    role?: SortOrder
    user_id?: SortOrder
  }

  export type admin_userMinOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    role?: SortOrder
    user_id?: SortOrder
  }

  export type EnumAdminRoleNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAdminRoleNullableWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAdminRoleNullableFilter<$PrismaModel>
    _max?: NestedEnumAdminRoleNullableFilter<$PrismaModel>
  }

  export type faqQuestionCountOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
  }

  export type faqQuestionAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type faqQuestionMaxOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
  }

  export type faqQuestionMinOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
  }

  export type faqQuestionSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type sessionCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    active_expires?: SortOrder
    idle_expires?: SortOrder
  }

  export type sessionAvgOrderByAggregateInput = {
    active_expires?: SortOrder
    idle_expires?: SortOrder
  }

  export type sessionMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    active_expires?: SortOrder
    idle_expires?: SortOrder
  }

  export type sessionMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    active_expires?: SortOrder
    idle_expires?: SortOrder
  }

  export type sessionSumOrderByAggregateInput = {
    active_expires?: SortOrder
    idle_expires?: SortOrder
  }

  export type admin_editingCountOrderByAggregateInput = {
    id?: SortOrder
    updatedAt?: SortOrder
    genericEmailBody?: SortOrder
    genericEmailHeader?: SortOrder
    aboutContent?: SortOrder
    aboutImageUrl?: SortOrder
    landingPageDesc?: SortOrder
    landingPageHeading?: SortOrder
    landingPageHero?: SortOrder
    landingPageSectionDesc?: SortOrder
    landingPageSectionHeading?: SortOrder
    landingPageSectionHero?: SortOrder
    conditionsSale?: SortOrder
    conditionsUse?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type admin_editingAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_editingMaxOrderByAggregateInput = {
    id?: SortOrder
    updatedAt?: SortOrder
    genericEmailBody?: SortOrder
    genericEmailHeader?: SortOrder
    aboutContent?: SortOrder
    aboutImageUrl?: SortOrder
    landingPageDesc?: SortOrder
    landingPageHeading?: SortOrder
    landingPageHero?: SortOrder
    landingPageSectionDesc?: SortOrder
    landingPageSectionHeading?: SortOrder
    landingPageSectionHero?: SortOrder
    conditionsSale?: SortOrder
    conditionsUse?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type admin_editingMinOrderByAggregateInput = {
    id?: SortOrder
    updatedAt?: SortOrder
    genericEmailBody?: SortOrder
    genericEmailHeader?: SortOrder
    aboutContent?: SortOrder
    aboutImageUrl?: SortOrder
    landingPageDesc?: SortOrder
    landingPageHeading?: SortOrder
    landingPageHero?: SortOrder
    landingPageSectionDesc?: SortOrder
    landingPageSectionHeading?: SortOrder
    landingPageSectionHero?: SortOrder
    conditionsSale?: SortOrder
    conditionsUse?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type admin_editingSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_notificationCountOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    title?: SortOrder
    link?: SortOrder
    description?: SortOrder
  }

  export type admin_notificationAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_notificationMaxOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    title?: SortOrder
    link?: SortOrder
    description?: SortOrder
  }

  export type admin_notificationMinOrderByAggregateInput = {
    id?: SortOrder
    created_at?: SortOrder
    title?: SortOrder
    link?: SortOrder
    description?: SortOrder
  }

  export type admin_notificationSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EnumNotificationStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationStatus | EnumNotificationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationStatusFilter<$PrismaModel> | $Enums.NotificationStatus
  }

  export type admin_notification_statusCountOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    newExpertApplication?: SortOrder
    newInvitationAccepted?: SortOrder
    newIdVerification?: SortOrder
  }

  export type admin_notification_statusAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type admin_notification_statusMaxOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    newExpertApplication?: SortOrder
    newInvitationAccepted?: SortOrder
    newIdVerification?: SortOrder
  }

  export type admin_notification_statusMinOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    newExpertApplication?: SortOrder
    newInvitationAccepted?: SortOrder
    newIdVerification?: SortOrder
  }

  export type admin_notification_statusSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EnumNotificationStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationStatus | EnumNotificationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationStatusWithAggregatesFilter<$PrismaModel> | $Enums.NotificationStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumNotificationStatusFilter<$PrismaModel>
    _max?: NestedEnumNotificationStatusFilter<$PrismaModel>
  }

  export type Admin_expert_applicationNullableRelationFilter = {
    is?: admin_expert_applicationWhereInput | null
    isNot?: admin_expert_applicationWhereInput | null
  }

  export type ExpertApplicationQuestionRelationFilter = {
    is?: expertApplicationQuestionWhereInput
    isNot?: expertApplicationQuestionWhereInput
  }

  export type expertApplicationAnswerCountOrderByAggregateInput = {
    id?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    userId?: SortOrder
    questionId?: SortOrder
    admin_expert_applicationId?: SortOrder
  }

  export type expertApplicationAnswerMaxOrderByAggregateInput = {
    id?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    userId?: SortOrder
    questionId?: SortOrder
    admin_expert_applicationId?: SortOrder
  }

  export type expertApplicationAnswerMinOrderByAggregateInput = {
    id?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    userId?: SortOrder
    questionId?: SortOrder
    admin_expert_applicationId?: SortOrder
  }

  export type admin_expert_applicationCountOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    userId?: SortOrder
  }

  export type admin_expert_applicationMaxOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    userId?: SortOrder
  }

  export type admin_expert_applicationMinOrderByAggregateInput = {
    id?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    userId?: SortOrder
  }

  export type expertApplicationQuestionCountOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    created_at?: SortOrder
    order?: SortOrder
  }

  export type expertApplicationQuestionAvgOrderByAggregateInput = {
    order?: SortOrder
  }

  export type expertApplicationQuestionMaxOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    created_at?: SortOrder
    order?: SortOrder
  }

  export type expertApplicationQuestionMinOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    created_at?: SortOrder
    order?: SortOrder
  }

  export type expertApplicationQuestionSumOrderByAggregateInput = {
    order?: SortOrder
  }

  export type UserCreatevideosInput = {
    set: string[]
  }

  export type UserCreateFavoriteExpertIdsInput = {
    set: string[]
  }

  export type AppointmentCreateNestedManyWithoutClientInput = {
    create?: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput> | AppointmentCreateWithoutClientInput[] | AppointmentUncheckedCreateWithoutClientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutClientInput | AppointmentCreateOrConnectWithoutClientInput[]
    createMany?: AppointmentCreateManyClientInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AvailabilityCreateNestedManyWithoutUserInput = {
    create?: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput> | AvailabilityCreateWithoutUserInput[] | AvailabilityUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutUserInput | AvailabilityCreateOrConnectWithoutUserInput[]
    createMany?: AvailabilityCreateManyUserInputEnvelope
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
  }

  export type ChatCreateNestedManyWithoutClientInput = {
    create?: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput> | ChatCreateWithoutClientInput[] | ChatUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutClientInput | ChatCreateOrConnectWithoutClientInput[]
    createMany?: ChatCreateManyClientInputEnvelope
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
  }

  export type ChatMessageCreateNestedManyWithoutSenderInput = {
    create?: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput> | ChatMessageCreateWithoutSenderInput[] | ChatMessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutSenderInput | ChatMessageCreateOrConnectWithoutSenderInput[]
    createMany?: ChatMessageCreateManySenderInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type ClientReviewCreateNestedManyWithoutClientInput = {
    create?: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput> | ClientReviewCreateWithoutClientInput[] | ClientReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutClientInput | ClientReviewCreateOrConnectWithoutClientInput[]
    createMany?: ClientReviewCreateManyClientInputEnvelope
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
  }

  export type EducationCreateNestedManyWithoutUserInput = {
    create?: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput> | EducationCreateWithoutUserInput[] | EducationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EducationCreateOrConnectWithoutUserInput | EducationCreateOrConnectWithoutUserInput[]
    createMany?: EducationCreateManyUserInputEnvelope
    connect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
  }

  export type ExperienceCreateNestedManyWithoutUserInput = {
    create?: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput> | ExperienceCreateWithoutUserInput[] | ExperienceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExperienceCreateOrConnectWithoutUserInput | ExperienceCreateOrConnectWithoutUserInput[]
    createMany?: ExperienceCreateManyUserInputEnvelope
    connect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
  }

  export type ExpertCreateNestedOneWithoutUserInput = {
    create?: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutUserInput
    connect?: ExpertWhereUniqueInput
  }

  export type ExpertReviewCreateNestedManyWithoutClientInput = {
    create?: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput> | ExpertReviewCreateWithoutClientInput[] | ExpertReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutClientInput | ExpertReviewCreateOrConnectWithoutClientInput[]
    createMany?: ExpertReviewCreateManyClientInputEnvelope
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
  }

  export type ExpertiseCreateNestedManyWithoutUserInput = {
    create?: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput> | ExpertiseCreateWithoutUserInput[] | ExpertiseUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExpertiseCreateOrConnectWithoutUserInput | ExpertiseCreateOrConnectWithoutUserInput[]
    createMany?: ExpertiseCreateManyUserInputEnvelope
    connect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
  }

  export type KeyCreateNestedManyWithoutUserInput = {
    create?: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput> | KeyCreateWithoutUserInput[] | KeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: KeyCreateOrConnectWithoutUserInput | KeyCreateOrConnectWithoutUserInput[]
    createMany?: KeyCreateManyUserInputEnvelope
    connect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
  }

  export type LanguageCreateNestedManyWithoutUserInput = {
    create?: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput> | LanguageCreateWithoutUserInput[] | LanguageUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LanguageCreateOrConnectWithoutUserInput | LanguageCreateOrConnectWithoutUserInput[]
    createMany?: LanguageCreateManyUserInputEnvelope
    connect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
  }

  export type QuestionCreateNestedManyWithoutUserInput = {
    create?: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput> | QuestionCreateWithoutUserInput[] | QuestionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuestionCreateOrConnectWithoutUserInput | QuestionCreateOrConnectWithoutUserInput[]
    createMany?: QuestionCreateManyUserInputEnvelope
    connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
  }

  export type ReplyCreateNestedManyWithoutUserInput = {
    create?: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput> | ReplyCreateWithoutUserInput[] | ReplyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutUserInput | ReplyCreateOrConnectWithoutUserInput[]
    createMany?: ReplyCreateManyUserInputEnvelope
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
  }

  export type admin_expert_applicationCreateNestedManyWithoutUserInput = {
    create?: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput> | admin_expert_applicationCreateWithoutUserInput[] | admin_expert_applicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutUserInput | admin_expert_applicationCreateOrConnectWithoutUserInput[]
    createMany?: admin_expert_applicationCreateManyUserInputEnvelope
    connect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
  }

  export type admin_userCreateNestedOneWithoutUserInput = {
    create?: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
    connectOrCreate?: admin_userCreateOrConnectWithoutUserInput
    connect?: admin_userWhereUniqueInput
  }

  export type email_verification_tokenCreateNestedManyWithoutUserInput = {
    create?: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput> | email_verification_tokenCreateWithoutUserInput[] | email_verification_tokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: email_verification_tokenCreateOrConnectWithoutUserInput | email_verification_tokenCreateOrConnectWithoutUserInput[]
    createMany?: email_verification_tokenCreateManyUserInputEnvelope
    connect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
  }

  export type expertApplicationAnswerCreateNestedManyWithoutUserInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput> | expertApplicationAnswerCreateWithoutUserInput[] | expertApplicationAnswerUncheckedCreateWithoutUserInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutUserInput | expertApplicationAnswerCreateOrConnectWithoutUserInput[]
    createMany?: expertApplicationAnswerCreateManyUserInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type id_verificationCreateNestedManyWithoutUserInput = {
    create?: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput> | id_verificationCreateWithoutUserInput[] | id_verificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: id_verificationCreateOrConnectWithoutUserInput | id_verificationCreateOrConnectWithoutUserInput[]
    createMany?: id_verificationCreateManyUserInputEnvelope
    connect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
  }

  export type sessionCreateNestedManyWithoutUserInput = {
    create?: XOR<sessionCreateWithoutUserInput, sessionUncheckedCreateWithoutUserInput> | sessionCreateWithoutUserInput[] | sessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: sessionCreateOrConnectWithoutUserInput | sessionCreateOrConnectWithoutUserInput[]
    createMany?: sessionCreateManyUserInputEnvelope
    connect?: sessionWhereUniqueInput | sessionWhereUniqueInput[]
  }

  export type AppointmentUncheckedCreateNestedManyWithoutClientInput = {
    create?: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput> | AppointmentCreateWithoutClientInput[] | AppointmentUncheckedCreateWithoutClientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutClientInput | AppointmentCreateOrConnectWithoutClientInput[]
    createMany?: AppointmentCreateManyClientInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AvailabilityUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput> | AvailabilityCreateWithoutUserInput[] | AvailabilityUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutUserInput | AvailabilityCreateOrConnectWithoutUserInput[]
    createMany?: AvailabilityCreateManyUserInputEnvelope
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
  }

  export type ChatUncheckedCreateNestedManyWithoutClientInput = {
    create?: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput> | ChatCreateWithoutClientInput[] | ChatUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutClientInput | ChatCreateOrConnectWithoutClientInput[]
    createMany?: ChatCreateManyClientInputEnvelope
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
  }

  export type ChatMessageUncheckedCreateNestedManyWithoutSenderInput = {
    create?: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput> | ChatMessageCreateWithoutSenderInput[] | ChatMessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutSenderInput | ChatMessageCreateOrConnectWithoutSenderInput[]
    createMany?: ChatMessageCreateManySenderInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type ClientReviewUncheckedCreateNestedManyWithoutClientInput = {
    create?: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput> | ClientReviewCreateWithoutClientInput[] | ClientReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutClientInput | ClientReviewCreateOrConnectWithoutClientInput[]
    createMany?: ClientReviewCreateManyClientInputEnvelope
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
  }

  export type EducationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput> | EducationCreateWithoutUserInput[] | EducationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EducationCreateOrConnectWithoutUserInput | EducationCreateOrConnectWithoutUserInput[]
    createMany?: EducationCreateManyUserInputEnvelope
    connect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
  }

  export type ExperienceUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput> | ExperienceCreateWithoutUserInput[] | ExperienceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExperienceCreateOrConnectWithoutUserInput | ExperienceCreateOrConnectWithoutUserInput[]
    createMany?: ExperienceCreateManyUserInputEnvelope
    connect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
  }

  export type ExpertUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutUserInput
    connect?: ExpertWhereUniqueInput
  }

  export type ExpertReviewUncheckedCreateNestedManyWithoutClientInput = {
    create?: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput> | ExpertReviewCreateWithoutClientInput[] | ExpertReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutClientInput | ExpertReviewCreateOrConnectWithoutClientInput[]
    createMany?: ExpertReviewCreateManyClientInputEnvelope
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
  }

  export type ExpertiseUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput> | ExpertiseCreateWithoutUserInput[] | ExpertiseUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExpertiseCreateOrConnectWithoutUserInput | ExpertiseCreateOrConnectWithoutUserInput[]
    createMany?: ExpertiseCreateManyUserInputEnvelope
    connect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
  }

  export type KeyUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput> | KeyCreateWithoutUserInput[] | KeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: KeyCreateOrConnectWithoutUserInput | KeyCreateOrConnectWithoutUserInput[]
    createMany?: KeyCreateManyUserInputEnvelope
    connect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
  }

  export type LanguageUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput> | LanguageCreateWithoutUserInput[] | LanguageUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LanguageCreateOrConnectWithoutUserInput | LanguageCreateOrConnectWithoutUserInput[]
    createMany?: LanguageCreateManyUserInputEnvelope
    connect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
  }

  export type QuestionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput> | QuestionCreateWithoutUserInput[] | QuestionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuestionCreateOrConnectWithoutUserInput | QuestionCreateOrConnectWithoutUserInput[]
    createMany?: QuestionCreateManyUserInputEnvelope
    connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
  }

  export type ReplyUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput> | ReplyCreateWithoutUserInput[] | ReplyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutUserInput | ReplyCreateOrConnectWithoutUserInput[]
    createMany?: ReplyCreateManyUserInputEnvelope
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
  }

  export type admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput> | admin_expert_applicationCreateWithoutUserInput[] | admin_expert_applicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutUserInput | admin_expert_applicationCreateOrConnectWithoutUserInput[]
    createMany?: admin_expert_applicationCreateManyUserInputEnvelope
    connect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
  }

  export type admin_userUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
    connectOrCreate?: admin_userCreateOrConnectWithoutUserInput
    connect?: admin_userWhereUniqueInput
  }

  export type email_verification_tokenUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput> | email_verification_tokenCreateWithoutUserInput[] | email_verification_tokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: email_verification_tokenCreateOrConnectWithoutUserInput | email_verification_tokenCreateOrConnectWithoutUserInput[]
    createMany?: email_verification_tokenCreateManyUserInputEnvelope
    connect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
  }

  export type expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput> | expertApplicationAnswerCreateWithoutUserInput[] | expertApplicationAnswerUncheckedCreateWithoutUserInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutUserInput | expertApplicationAnswerCreateOrConnectWithoutUserInput[]
    createMany?: expertApplicationAnswerCreateManyUserInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type id_verificationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput> | id_verificationCreateWithoutUserInput[] | id_verificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: id_verificationCreateOrConnectWithoutUserInput | id_verificationCreateOrConnectWithoutUserInput[]
    createMany?: id_verificationCreateManyUserInputEnvelope
    connect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
  }

  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 NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type UserUpdatevideosInput = {
    set?: string[]
    push?: string | string[]
  }

  export type EnumCountryCodeFieldUpdateOperationsInput = {
    set?: $Enums.CountryCode
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type UserUpdateFavoriteExpertIdsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type AppointmentUpdateManyWithoutClientNestedInput = {
    create?: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput> | AppointmentCreateWithoutClientInput[] | AppointmentUncheckedCreateWithoutClientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutClientInput | AppointmentCreateOrConnectWithoutClientInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutClientInput | AppointmentUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: AppointmentCreateManyClientInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutClientInput | AppointmentUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutClientInput | AppointmentUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AvailabilityUpdateManyWithoutUserNestedInput = {
    create?: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput> | AvailabilityCreateWithoutUserInput[] | AvailabilityUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutUserInput | AvailabilityCreateOrConnectWithoutUserInput[]
    upsert?: AvailabilityUpsertWithWhereUniqueWithoutUserInput | AvailabilityUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AvailabilityCreateManyUserInputEnvelope
    set?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    disconnect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    delete?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    update?: AvailabilityUpdateWithWhereUniqueWithoutUserInput | AvailabilityUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AvailabilityUpdateManyWithWhereWithoutUserInput | AvailabilityUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
  }

  export type ChatUpdateManyWithoutClientNestedInput = {
    create?: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput> | ChatCreateWithoutClientInput[] | ChatUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutClientInput | ChatCreateOrConnectWithoutClientInput[]
    upsert?: ChatUpsertWithWhereUniqueWithoutClientInput | ChatUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ChatCreateManyClientInputEnvelope
    set?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    disconnect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    delete?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    update?: ChatUpdateWithWhereUniqueWithoutClientInput | ChatUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ChatUpdateManyWithWhereWithoutClientInput | ChatUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ChatScalarWhereInput | ChatScalarWhereInput[]
  }

  export type ChatMessageUpdateManyWithoutSenderNestedInput = {
    create?: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput> | ChatMessageCreateWithoutSenderInput[] | ChatMessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutSenderInput | ChatMessageCreateOrConnectWithoutSenderInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutSenderInput | ChatMessageUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: ChatMessageCreateManySenderInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutSenderInput | ChatMessageUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutSenderInput | ChatMessageUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ClientReviewUpdateManyWithoutClientNestedInput = {
    create?: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput> | ClientReviewCreateWithoutClientInput[] | ClientReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutClientInput | ClientReviewCreateOrConnectWithoutClientInput[]
    upsert?: ClientReviewUpsertWithWhereUniqueWithoutClientInput | ClientReviewUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ClientReviewCreateManyClientInputEnvelope
    set?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    disconnect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    delete?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    update?: ClientReviewUpdateWithWhereUniqueWithoutClientInput | ClientReviewUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ClientReviewUpdateManyWithWhereWithoutClientInput | ClientReviewUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
  }

  export type EducationUpdateManyWithoutUserNestedInput = {
    create?: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput> | EducationCreateWithoutUserInput[] | EducationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EducationCreateOrConnectWithoutUserInput | EducationCreateOrConnectWithoutUserInput[]
    upsert?: EducationUpsertWithWhereUniqueWithoutUserInput | EducationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EducationCreateManyUserInputEnvelope
    set?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    disconnect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    delete?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    connect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    update?: EducationUpdateWithWhereUniqueWithoutUserInput | EducationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EducationUpdateManyWithWhereWithoutUserInput | EducationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EducationScalarWhereInput | EducationScalarWhereInput[]
  }

  export type ExperienceUpdateManyWithoutUserNestedInput = {
    create?: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput> | ExperienceCreateWithoutUserInput[] | ExperienceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExperienceCreateOrConnectWithoutUserInput | ExperienceCreateOrConnectWithoutUserInput[]
    upsert?: ExperienceUpsertWithWhereUniqueWithoutUserInput | ExperienceUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ExperienceCreateManyUserInputEnvelope
    set?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    disconnect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    delete?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    connect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    update?: ExperienceUpdateWithWhereUniqueWithoutUserInput | ExperienceUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ExperienceUpdateManyWithWhereWithoutUserInput | ExperienceUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ExperienceScalarWhereInput | ExperienceScalarWhereInput[]
  }

  export type ExpertUpdateOneWithoutUserNestedInput = {
    create?: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutUserInput
    upsert?: ExpertUpsertWithoutUserInput
    disconnect?: ExpertWhereInput | boolean
    delete?: ExpertWhereInput | boolean
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutUserInput, ExpertUpdateWithoutUserInput>, ExpertUncheckedUpdateWithoutUserInput>
  }

  export type ExpertReviewUpdateManyWithoutClientNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput> | ExpertReviewCreateWithoutClientInput[] | ExpertReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutClientInput | ExpertReviewCreateOrConnectWithoutClientInput[]
    upsert?: ExpertReviewUpsertWithWhereUniqueWithoutClientInput | ExpertReviewUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ExpertReviewCreateManyClientInputEnvelope
    set?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    disconnect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    delete?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    update?: ExpertReviewUpdateWithWhereUniqueWithoutClientInput | ExpertReviewUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ExpertReviewUpdateManyWithWhereWithoutClientInput | ExpertReviewUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
  }

  export type ExpertiseUpdateManyWithoutUserNestedInput = {
    create?: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput> | ExpertiseCreateWithoutUserInput[] | ExpertiseUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExpertiseCreateOrConnectWithoutUserInput | ExpertiseCreateOrConnectWithoutUserInput[]
    upsert?: ExpertiseUpsertWithWhereUniqueWithoutUserInput | ExpertiseUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ExpertiseCreateManyUserInputEnvelope
    set?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    disconnect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    delete?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    connect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    update?: ExpertiseUpdateWithWhereUniqueWithoutUserInput | ExpertiseUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ExpertiseUpdateManyWithWhereWithoutUserInput | ExpertiseUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ExpertiseScalarWhereInput | ExpertiseScalarWhereInput[]
  }

  export type KeyUpdateManyWithoutUserNestedInput = {
    create?: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput> | KeyCreateWithoutUserInput[] | KeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: KeyCreateOrConnectWithoutUserInput | KeyCreateOrConnectWithoutUserInput[]
    upsert?: KeyUpsertWithWhereUniqueWithoutUserInput | KeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: KeyCreateManyUserInputEnvelope
    set?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    disconnect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    delete?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    connect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    update?: KeyUpdateWithWhereUniqueWithoutUserInput | KeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: KeyUpdateManyWithWhereWithoutUserInput | KeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: KeyScalarWhereInput | KeyScalarWhereInput[]
  }

  export type LanguageUpdateManyWithoutUserNestedInput = {
    create?: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput> | LanguageCreateWithoutUserInput[] | LanguageUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LanguageCreateOrConnectWithoutUserInput | LanguageCreateOrConnectWithoutUserInput[]
    upsert?: LanguageUpsertWithWhereUniqueWithoutUserInput | LanguageUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: LanguageCreateManyUserInputEnvelope
    set?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    disconnect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    delete?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    connect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    update?: LanguageUpdateWithWhereUniqueWithoutUserInput | LanguageUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: LanguageUpdateManyWithWhereWithoutUserInput | LanguageUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: LanguageScalarWhereInput | LanguageScalarWhereInput[]
  }

  export type QuestionUpdateManyWithoutUserNestedInput = {
    create?: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput> | QuestionCreateWithoutUserInput[] | QuestionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuestionCreateOrConnectWithoutUserInput | QuestionCreateOrConnectWithoutUserInput[]
    upsert?: QuestionUpsertWithWhereUniqueWithoutUserInput | QuestionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: QuestionCreateManyUserInputEnvelope
    set?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    disconnect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    delete?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    update?: QuestionUpdateWithWhereUniqueWithoutUserInput | QuestionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: QuestionUpdateManyWithWhereWithoutUserInput | QuestionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
  }

  export type ReplyUpdateManyWithoutUserNestedInput = {
    create?: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput> | ReplyCreateWithoutUserInput[] | ReplyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutUserInput | ReplyCreateOrConnectWithoutUserInput[]
    upsert?: ReplyUpsertWithWhereUniqueWithoutUserInput | ReplyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ReplyCreateManyUserInputEnvelope
    set?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    disconnect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    delete?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    update?: ReplyUpdateWithWhereUniqueWithoutUserInput | ReplyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ReplyUpdateManyWithWhereWithoutUserInput | ReplyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
  }

  export type admin_expert_applicationUpdateManyWithoutUserNestedInput = {
    create?: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput> | admin_expert_applicationCreateWithoutUserInput[] | admin_expert_applicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutUserInput | admin_expert_applicationCreateOrConnectWithoutUserInput[]
    upsert?: admin_expert_applicationUpsertWithWhereUniqueWithoutUserInput | admin_expert_applicationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: admin_expert_applicationCreateManyUserInputEnvelope
    set?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    disconnect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    delete?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    connect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    update?: admin_expert_applicationUpdateWithWhereUniqueWithoutUserInput | admin_expert_applicationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: admin_expert_applicationUpdateManyWithWhereWithoutUserInput | admin_expert_applicationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: admin_expert_applicationScalarWhereInput | admin_expert_applicationScalarWhereInput[]
  }

  export type admin_userUpdateOneWithoutUserNestedInput = {
    create?: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
    connectOrCreate?: admin_userCreateOrConnectWithoutUserInput
    upsert?: admin_userUpsertWithoutUserInput
    disconnect?: admin_userWhereInput | boolean
    delete?: admin_userWhereInput | boolean
    connect?: admin_userWhereUniqueInput
    update?: XOR<XOR<admin_userUpdateToOneWithWhereWithoutUserInput, admin_userUpdateWithoutUserInput>, admin_userUncheckedUpdateWithoutUserInput>
  }

  export type email_verification_tokenUpdateManyWithoutUserNestedInput = {
    create?: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput> | email_verification_tokenCreateWithoutUserInput[] | email_verification_tokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: email_verification_tokenCreateOrConnectWithoutUserInput | email_verification_tokenCreateOrConnectWithoutUserInput[]
    upsert?: email_verification_tokenUpsertWithWhereUniqueWithoutUserInput | email_verification_tokenUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: email_verification_tokenCreateManyUserInputEnvelope
    set?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    disconnect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    delete?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    connect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    update?: email_verification_tokenUpdateWithWhereUniqueWithoutUserInput | email_verification_tokenUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: email_verification_tokenUpdateManyWithWhereWithoutUserInput | email_verification_tokenUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: email_verification_tokenScalarWhereInput | email_verification_tokenScalarWhereInput[]
  }

  export type expertApplicationAnswerUpdateManyWithoutUserNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput> | expertApplicationAnswerCreateWithoutUserInput[] | expertApplicationAnswerUncheckedCreateWithoutUserInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutUserInput | expertApplicationAnswerCreateOrConnectWithoutUserInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutUserInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: expertApplicationAnswerCreateManyUserInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutUserInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutUserInput | expertApplicationAnswerUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type id_verificationUpdateManyWithoutUserNestedInput = {
    create?: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput> | id_verificationCreateWithoutUserInput[] | id_verificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: id_verificationCreateOrConnectWithoutUserInput | id_verificationCreateOrConnectWithoutUserInput[]
    upsert?: id_verificationUpsertWithWhereUniqueWithoutUserInput | id_verificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: id_verificationCreateManyUserInputEnvelope
    set?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    disconnect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    delete?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    connect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    update?: id_verificationUpdateWithWhereUniqueWithoutUserInput | id_verificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: id_verificationUpdateManyWithWhereWithoutUserInput | id_verificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: id_verificationScalarWhereInput | id_verificationScalarWhereInput[]
  }

  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 AppointmentUncheckedUpdateManyWithoutClientNestedInput = {
    create?: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput> | AppointmentCreateWithoutClientInput[] | AppointmentUncheckedCreateWithoutClientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutClientInput | AppointmentCreateOrConnectWithoutClientInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutClientInput | AppointmentUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: AppointmentCreateManyClientInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutClientInput | AppointmentUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutClientInput | AppointmentUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AvailabilityUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput> | AvailabilityCreateWithoutUserInput[] | AvailabilityUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutUserInput | AvailabilityCreateOrConnectWithoutUserInput[]
    upsert?: AvailabilityUpsertWithWhereUniqueWithoutUserInput | AvailabilityUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AvailabilityCreateManyUserInputEnvelope
    set?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    disconnect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    delete?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    update?: AvailabilityUpdateWithWhereUniqueWithoutUserInput | AvailabilityUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AvailabilityUpdateManyWithWhereWithoutUserInput | AvailabilityUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
  }

  export type ChatUncheckedUpdateManyWithoutClientNestedInput = {
    create?: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput> | ChatCreateWithoutClientInput[] | ChatUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutClientInput | ChatCreateOrConnectWithoutClientInput[]
    upsert?: ChatUpsertWithWhereUniqueWithoutClientInput | ChatUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ChatCreateManyClientInputEnvelope
    set?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    disconnect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    delete?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    update?: ChatUpdateWithWhereUniqueWithoutClientInput | ChatUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ChatUpdateManyWithWhereWithoutClientInput | ChatUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ChatScalarWhereInput | ChatScalarWhereInput[]
  }

  export type ChatMessageUncheckedUpdateManyWithoutSenderNestedInput = {
    create?: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput> | ChatMessageCreateWithoutSenderInput[] | ChatMessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutSenderInput | ChatMessageCreateOrConnectWithoutSenderInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutSenderInput | ChatMessageUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: ChatMessageCreateManySenderInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutSenderInput | ChatMessageUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutSenderInput | ChatMessageUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ClientReviewUncheckedUpdateManyWithoutClientNestedInput = {
    create?: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput> | ClientReviewCreateWithoutClientInput[] | ClientReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutClientInput | ClientReviewCreateOrConnectWithoutClientInput[]
    upsert?: ClientReviewUpsertWithWhereUniqueWithoutClientInput | ClientReviewUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ClientReviewCreateManyClientInputEnvelope
    set?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    disconnect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    delete?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    update?: ClientReviewUpdateWithWhereUniqueWithoutClientInput | ClientReviewUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ClientReviewUpdateManyWithWhereWithoutClientInput | ClientReviewUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
  }

  export type EducationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput> | EducationCreateWithoutUserInput[] | EducationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EducationCreateOrConnectWithoutUserInput | EducationCreateOrConnectWithoutUserInput[]
    upsert?: EducationUpsertWithWhereUniqueWithoutUserInput | EducationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EducationCreateManyUserInputEnvelope
    set?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    disconnect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    delete?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    connect?: EducationWhereUniqueInput | EducationWhereUniqueInput[]
    update?: EducationUpdateWithWhereUniqueWithoutUserInput | EducationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EducationUpdateManyWithWhereWithoutUserInput | EducationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EducationScalarWhereInput | EducationScalarWhereInput[]
  }

  export type ExperienceUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput> | ExperienceCreateWithoutUserInput[] | ExperienceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExperienceCreateOrConnectWithoutUserInput | ExperienceCreateOrConnectWithoutUserInput[]
    upsert?: ExperienceUpsertWithWhereUniqueWithoutUserInput | ExperienceUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ExperienceCreateManyUserInputEnvelope
    set?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    disconnect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    delete?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    connect?: ExperienceWhereUniqueInput | ExperienceWhereUniqueInput[]
    update?: ExperienceUpdateWithWhereUniqueWithoutUserInput | ExperienceUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ExperienceUpdateManyWithWhereWithoutUserInput | ExperienceUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ExperienceScalarWhereInput | ExperienceScalarWhereInput[]
  }

  export type ExpertUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutUserInput
    upsert?: ExpertUpsertWithoutUserInput
    disconnect?: ExpertWhereInput | boolean
    delete?: ExpertWhereInput | boolean
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutUserInput, ExpertUpdateWithoutUserInput>, ExpertUncheckedUpdateWithoutUserInput>
  }

  export type ExpertReviewUncheckedUpdateManyWithoutClientNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput> | ExpertReviewCreateWithoutClientInput[] | ExpertReviewUncheckedCreateWithoutClientInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutClientInput | ExpertReviewCreateOrConnectWithoutClientInput[]
    upsert?: ExpertReviewUpsertWithWhereUniqueWithoutClientInput | ExpertReviewUpsertWithWhereUniqueWithoutClientInput[]
    createMany?: ExpertReviewCreateManyClientInputEnvelope
    set?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    disconnect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    delete?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    update?: ExpertReviewUpdateWithWhereUniqueWithoutClientInput | ExpertReviewUpdateWithWhereUniqueWithoutClientInput[]
    updateMany?: ExpertReviewUpdateManyWithWhereWithoutClientInput | ExpertReviewUpdateManyWithWhereWithoutClientInput[]
    deleteMany?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
  }

  export type ExpertiseUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput> | ExpertiseCreateWithoutUserInput[] | ExpertiseUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ExpertiseCreateOrConnectWithoutUserInput | ExpertiseCreateOrConnectWithoutUserInput[]
    upsert?: ExpertiseUpsertWithWhereUniqueWithoutUserInput | ExpertiseUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ExpertiseCreateManyUserInputEnvelope
    set?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    disconnect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    delete?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    connect?: ExpertiseWhereUniqueInput | ExpertiseWhereUniqueInput[]
    update?: ExpertiseUpdateWithWhereUniqueWithoutUserInput | ExpertiseUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ExpertiseUpdateManyWithWhereWithoutUserInput | ExpertiseUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ExpertiseScalarWhereInput | ExpertiseScalarWhereInput[]
  }

  export type KeyUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput> | KeyCreateWithoutUserInput[] | KeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: KeyCreateOrConnectWithoutUserInput | KeyCreateOrConnectWithoutUserInput[]
    upsert?: KeyUpsertWithWhereUniqueWithoutUserInput | KeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: KeyCreateManyUserInputEnvelope
    set?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    disconnect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    delete?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    connect?: KeyWhereUniqueInput | KeyWhereUniqueInput[]
    update?: KeyUpdateWithWhereUniqueWithoutUserInput | KeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: KeyUpdateManyWithWhereWithoutUserInput | KeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: KeyScalarWhereInput | KeyScalarWhereInput[]
  }

  export type LanguageUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput> | LanguageCreateWithoutUserInput[] | LanguageUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LanguageCreateOrConnectWithoutUserInput | LanguageCreateOrConnectWithoutUserInput[]
    upsert?: LanguageUpsertWithWhereUniqueWithoutUserInput | LanguageUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: LanguageCreateManyUserInputEnvelope
    set?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    disconnect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    delete?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    connect?: LanguageWhereUniqueInput | LanguageWhereUniqueInput[]
    update?: LanguageUpdateWithWhereUniqueWithoutUserInput | LanguageUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: LanguageUpdateManyWithWhereWithoutUserInput | LanguageUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: LanguageScalarWhereInput | LanguageScalarWhereInput[]
  }

  export type QuestionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput> | QuestionCreateWithoutUserInput[] | QuestionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuestionCreateOrConnectWithoutUserInput | QuestionCreateOrConnectWithoutUserInput[]
    upsert?: QuestionUpsertWithWhereUniqueWithoutUserInput | QuestionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: QuestionCreateManyUserInputEnvelope
    set?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    disconnect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    delete?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
    update?: QuestionUpdateWithWhereUniqueWithoutUserInput | QuestionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: QuestionUpdateManyWithWhereWithoutUserInput | QuestionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
  }

  export type ReplyUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput> | ReplyCreateWithoutUserInput[] | ReplyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutUserInput | ReplyCreateOrConnectWithoutUserInput[]
    upsert?: ReplyUpsertWithWhereUniqueWithoutUserInput | ReplyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ReplyCreateManyUserInputEnvelope
    set?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    disconnect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    delete?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    update?: ReplyUpdateWithWhereUniqueWithoutUserInput | ReplyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ReplyUpdateManyWithWhereWithoutUserInput | ReplyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
  }

  export type admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput> | admin_expert_applicationCreateWithoutUserInput[] | admin_expert_applicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutUserInput | admin_expert_applicationCreateOrConnectWithoutUserInput[]
    upsert?: admin_expert_applicationUpsertWithWhereUniqueWithoutUserInput | admin_expert_applicationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: admin_expert_applicationCreateManyUserInputEnvelope
    set?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    disconnect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    delete?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    connect?: admin_expert_applicationWhereUniqueInput | admin_expert_applicationWhereUniqueInput[]
    update?: admin_expert_applicationUpdateWithWhereUniqueWithoutUserInput | admin_expert_applicationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: admin_expert_applicationUpdateManyWithWhereWithoutUserInput | admin_expert_applicationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: admin_expert_applicationScalarWhereInput | admin_expert_applicationScalarWhereInput[]
  }

  export type admin_userUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
    connectOrCreate?: admin_userCreateOrConnectWithoutUserInput
    upsert?: admin_userUpsertWithoutUserInput
    disconnect?: admin_userWhereInput | boolean
    delete?: admin_userWhereInput | boolean
    connect?: admin_userWhereUniqueInput
    update?: XOR<XOR<admin_userUpdateToOneWithWhereWithoutUserInput, admin_userUpdateWithoutUserInput>, admin_userUncheckedUpdateWithoutUserInput>
  }

  export type email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput> | email_verification_tokenCreateWithoutUserInput[] | email_verification_tokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: email_verification_tokenCreateOrConnectWithoutUserInput | email_verification_tokenCreateOrConnectWithoutUserInput[]
    upsert?: email_verification_tokenUpsertWithWhereUniqueWithoutUserInput | email_verification_tokenUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: email_verification_tokenCreateManyUserInputEnvelope
    set?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    disconnect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    delete?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    connect?: email_verification_tokenWhereUniqueInput | email_verification_tokenWhereUniqueInput[]
    update?: email_verification_tokenUpdateWithWhereUniqueWithoutUserInput | email_verification_tokenUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: email_verification_tokenUpdateManyWithWhereWithoutUserInput | email_verification_tokenUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: email_verification_tokenScalarWhereInput | email_verification_tokenScalarWhereInput[]
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput> | expertApplicationAnswerCreateWithoutUserInput[] | expertApplicationAnswerUncheckedCreateWithoutUserInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutUserInput | expertApplicationAnswerCreateOrConnectWithoutUserInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutUserInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: expertApplicationAnswerCreateManyUserInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutUserInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutUserInput | expertApplicationAnswerUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type id_verificationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput> | id_verificationCreateWithoutUserInput[] | id_verificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: id_verificationCreateOrConnectWithoutUserInput | id_verificationCreateOrConnectWithoutUserInput[]
    upsert?: id_verificationUpsertWithWhereUniqueWithoutUserInput | id_verificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: id_verificationCreateManyUserInputEnvelope
    set?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    disconnect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    delete?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    connect?: id_verificationWhereUniqueInput | id_verificationWhereUniqueInput[]
    update?: id_verificationUpdateWithWhereUniqueWithoutUserInput | id_verificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: id_verificationUpdateManyWithWhereWithoutUserInput | id_verificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: id_verificationScalarWhereInput | id_verificationScalarWhereInput[]
  }

  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 AppointmentCreateNestedManyWithoutExpertInput = {
    create?: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput> | AppointmentCreateWithoutExpertInput[] | AppointmentUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutExpertInput | AppointmentCreateOrConnectWithoutExpertInput[]
    createMany?: AppointmentCreateManyExpertInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AvailabilityCreateNestedManyWithoutExpertInput = {
    create?: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput> | AvailabilityCreateWithoutExpertInput[] | AvailabilityUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutExpertInput | AvailabilityCreateOrConnectWithoutExpertInput[]
    createMany?: AvailabilityCreateManyExpertInputEnvelope
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
  }

  export type ChatCreateNestedManyWithoutExpertInput = {
    create?: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput> | ChatCreateWithoutExpertInput[] | ChatUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutExpertInput | ChatCreateOrConnectWithoutExpertInput[]
    createMany?: ChatCreateManyExpertInputEnvelope
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
  }

  export type ChatMessageCreateNestedManyWithoutExpertInput = {
    create?: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput> | ChatMessageCreateWithoutExpertInput[] | ChatMessageUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutExpertInput | ChatMessageCreateOrConnectWithoutExpertInput[]
    createMany?: ChatMessageCreateManyExpertInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type ClientReviewCreateNestedManyWithoutExpertInput = {
    create?: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput> | ClientReviewCreateWithoutExpertInput[] | ClientReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutExpertInput | ClientReviewCreateOrConnectWithoutExpertInput[]
    createMany?: ClientReviewCreateManyExpertInputEnvelope
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutExpertInput = {
    create?: XOR<UserCreateWithoutExpertInput, UserUncheckedCreateWithoutExpertInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertInput
    connect?: UserWhereUniqueInput
  }

  export type ExpertReviewCreateNestedManyWithoutExpertInput = {
    create?: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput> | ExpertReviewCreateWithoutExpertInput[] | ExpertReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutExpertInput | ExpertReviewCreateOrConnectWithoutExpertInput[]
    createMany?: ExpertReviewCreateManyExpertInputEnvelope
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
  }

  export type StripeAccountCreateNestedOneWithoutExpertInput = {
    create?: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
    connectOrCreate?: StripeAccountCreateOrConnectWithoutExpertInput
    connect?: StripeAccountWhereUniqueInput
  }

  export type AppointmentUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput> | AppointmentCreateWithoutExpertInput[] | AppointmentUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutExpertInput | AppointmentCreateOrConnectWithoutExpertInput[]
    createMany?: AppointmentCreateManyExpertInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AvailabilityUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput> | AvailabilityCreateWithoutExpertInput[] | AvailabilityUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutExpertInput | AvailabilityCreateOrConnectWithoutExpertInput[]
    createMany?: AvailabilityCreateManyExpertInputEnvelope
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
  }

  export type ChatUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput> | ChatCreateWithoutExpertInput[] | ChatUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutExpertInput | ChatCreateOrConnectWithoutExpertInput[]
    createMany?: ChatCreateManyExpertInputEnvelope
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
  }

  export type ChatMessageUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput> | ChatMessageCreateWithoutExpertInput[] | ChatMessageUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutExpertInput | ChatMessageCreateOrConnectWithoutExpertInput[]
    createMany?: ChatMessageCreateManyExpertInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type ClientReviewUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput> | ClientReviewCreateWithoutExpertInput[] | ClientReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutExpertInput | ClientReviewCreateOrConnectWithoutExpertInput[]
    createMany?: ClientReviewCreateManyExpertInputEnvelope
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
  }

  export type ExpertReviewUncheckedCreateNestedManyWithoutExpertInput = {
    create?: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput> | ExpertReviewCreateWithoutExpertInput[] | ExpertReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutExpertInput | ExpertReviewCreateOrConnectWithoutExpertInput[]
    createMany?: ExpertReviewCreateManyExpertInputEnvelope
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
  }

  export type StripeAccountUncheckedCreateNestedOneWithoutExpertInput = {
    create?: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
    connectOrCreate?: StripeAccountCreateOrConnectWithoutExpertInput
    connect?: StripeAccountWhereUniqueInput
  }

  export type AppointmentUpdateManyWithoutExpertNestedInput = {
    create?: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput> | AppointmentCreateWithoutExpertInput[] | AppointmentUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutExpertInput | AppointmentCreateOrConnectWithoutExpertInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutExpertInput | AppointmentUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: AppointmentCreateManyExpertInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutExpertInput | AppointmentUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutExpertInput | AppointmentUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AvailabilityUpdateManyWithoutExpertNestedInput = {
    create?: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput> | AvailabilityCreateWithoutExpertInput[] | AvailabilityUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutExpertInput | AvailabilityCreateOrConnectWithoutExpertInput[]
    upsert?: AvailabilityUpsertWithWhereUniqueWithoutExpertInput | AvailabilityUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: AvailabilityCreateManyExpertInputEnvelope
    set?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    disconnect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    delete?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    update?: AvailabilityUpdateWithWhereUniqueWithoutExpertInput | AvailabilityUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: AvailabilityUpdateManyWithWhereWithoutExpertInput | AvailabilityUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
  }

  export type ChatUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput> | ChatCreateWithoutExpertInput[] | ChatUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutExpertInput | ChatCreateOrConnectWithoutExpertInput[]
    upsert?: ChatUpsertWithWhereUniqueWithoutExpertInput | ChatUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ChatCreateManyExpertInputEnvelope
    set?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    disconnect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    delete?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    update?: ChatUpdateWithWhereUniqueWithoutExpertInput | ChatUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ChatUpdateManyWithWhereWithoutExpertInput | ChatUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ChatScalarWhereInput | ChatScalarWhereInput[]
  }

  export type ChatMessageUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput> | ChatMessageCreateWithoutExpertInput[] | ChatMessageUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutExpertInput | ChatMessageCreateOrConnectWithoutExpertInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutExpertInput | ChatMessageUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ChatMessageCreateManyExpertInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutExpertInput | ChatMessageUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutExpertInput | ChatMessageUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ClientReviewUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput> | ClientReviewCreateWithoutExpertInput[] | ClientReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutExpertInput | ClientReviewCreateOrConnectWithoutExpertInput[]
    upsert?: ClientReviewUpsertWithWhereUniqueWithoutExpertInput | ClientReviewUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ClientReviewCreateManyExpertInputEnvelope
    set?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    disconnect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    delete?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    update?: ClientReviewUpdateWithWhereUniqueWithoutExpertInput | ClientReviewUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ClientReviewUpdateManyWithWhereWithoutExpertInput | ClientReviewUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
  }

  export type UserUpdateOneRequiredWithoutExpertNestedInput = {
    create?: XOR<UserCreateWithoutExpertInput, UserUncheckedCreateWithoutExpertInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertInput
    upsert?: UserUpsertWithoutExpertInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutExpertInput, UserUpdateWithoutExpertInput>, UserUncheckedUpdateWithoutExpertInput>
  }

  export type ExpertReviewUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput> | ExpertReviewCreateWithoutExpertInput[] | ExpertReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutExpertInput | ExpertReviewCreateOrConnectWithoutExpertInput[]
    upsert?: ExpertReviewUpsertWithWhereUniqueWithoutExpertInput | ExpertReviewUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ExpertReviewCreateManyExpertInputEnvelope
    set?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    disconnect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    delete?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    update?: ExpertReviewUpdateWithWhereUniqueWithoutExpertInput | ExpertReviewUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ExpertReviewUpdateManyWithWhereWithoutExpertInput | ExpertReviewUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
  }

  export type StripeAccountUpdateOneWithoutExpertNestedInput = {
    create?: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
    connectOrCreate?: StripeAccountCreateOrConnectWithoutExpertInput
    upsert?: StripeAccountUpsertWithoutExpertInput
    disconnect?: StripeAccountWhereInput | boolean
    delete?: StripeAccountWhereInput | boolean
    connect?: StripeAccountWhereUniqueInput
    update?: XOR<XOR<StripeAccountUpdateToOneWithWhereWithoutExpertInput, StripeAccountUpdateWithoutExpertInput>, StripeAccountUncheckedUpdateWithoutExpertInput>
  }

  export type AppointmentUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput> | AppointmentCreateWithoutExpertInput[] | AppointmentUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutExpertInput | AppointmentCreateOrConnectWithoutExpertInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutExpertInput | AppointmentUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: AppointmentCreateManyExpertInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutExpertInput | AppointmentUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutExpertInput | AppointmentUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AvailabilityUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput> | AvailabilityCreateWithoutExpertInput[] | AvailabilityUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: AvailabilityCreateOrConnectWithoutExpertInput | AvailabilityCreateOrConnectWithoutExpertInput[]
    upsert?: AvailabilityUpsertWithWhereUniqueWithoutExpertInput | AvailabilityUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: AvailabilityCreateManyExpertInputEnvelope
    set?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    disconnect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    delete?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    connect?: AvailabilityWhereUniqueInput | AvailabilityWhereUniqueInput[]
    update?: AvailabilityUpdateWithWhereUniqueWithoutExpertInput | AvailabilityUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: AvailabilityUpdateManyWithWhereWithoutExpertInput | AvailabilityUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
  }

  export type ChatUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput> | ChatCreateWithoutExpertInput[] | ChatUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatCreateOrConnectWithoutExpertInput | ChatCreateOrConnectWithoutExpertInput[]
    upsert?: ChatUpsertWithWhereUniqueWithoutExpertInput | ChatUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ChatCreateManyExpertInputEnvelope
    set?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    disconnect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    delete?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    connect?: ChatWhereUniqueInput | ChatWhereUniqueInput[]
    update?: ChatUpdateWithWhereUniqueWithoutExpertInput | ChatUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ChatUpdateManyWithWhereWithoutExpertInput | ChatUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ChatScalarWhereInput | ChatScalarWhereInput[]
  }

  export type ChatMessageUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput> | ChatMessageCreateWithoutExpertInput[] | ChatMessageUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutExpertInput | ChatMessageCreateOrConnectWithoutExpertInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutExpertInput | ChatMessageUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ChatMessageCreateManyExpertInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutExpertInput | ChatMessageUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutExpertInput | ChatMessageUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ClientReviewUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput> | ClientReviewCreateWithoutExpertInput[] | ClientReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ClientReviewCreateOrConnectWithoutExpertInput | ClientReviewCreateOrConnectWithoutExpertInput[]
    upsert?: ClientReviewUpsertWithWhereUniqueWithoutExpertInput | ClientReviewUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ClientReviewCreateManyExpertInputEnvelope
    set?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    disconnect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    delete?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    connect?: ClientReviewWhereUniqueInput | ClientReviewWhereUniqueInput[]
    update?: ClientReviewUpdateWithWhereUniqueWithoutExpertInput | ClientReviewUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ClientReviewUpdateManyWithWhereWithoutExpertInput | ClientReviewUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
  }

  export type ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput> | ExpertReviewCreateWithoutExpertInput[] | ExpertReviewUncheckedCreateWithoutExpertInput[]
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutExpertInput | ExpertReviewCreateOrConnectWithoutExpertInput[]
    upsert?: ExpertReviewUpsertWithWhereUniqueWithoutExpertInput | ExpertReviewUpsertWithWhereUniqueWithoutExpertInput[]
    createMany?: ExpertReviewCreateManyExpertInputEnvelope
    set?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    disconnect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    delete?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    connect?: ExpertReviewWhereUniqueInput | ExpertReviewWhereUniqueInput[]
    update?: ExpertReviewUpdateWithWhereUniqueWithoutExpertInput | ExpertReviewUpdateWithWhereUniqueWithoutExpertInput[]
    updateMany?: ExpertReviewUpdateManyWithWhereWithoutExpertInput | ExpertReviewUpdateManyWithWhereWithoutExpertInput[]
    deleteMany?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
  }

  export type StripeAccountUncheckedUpdateOneWithoutExpertNestedInput = {
    create?: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
    connectOrCreate?: StripeAccountCreateOrConnectWithoutExpertInput
    upsert?: StripeAccountUpsertWithoutExpertInput
    disconnect?: StripeAccountWhereInput | boolean
    delete?: StripeAccountWhereInput | boolean
    connect?: StripeAccountWhereUniqueInput
    update?: XOR<XOR<StripeAccountUpdateToOneWithWhereWithoutExpertInput, StripeAccountUpdateWithoutExpertInput>, StripeAccountUncheckedUpdateWithoutExpertInput>
  }

  export type UserCreateNestedOneWithoutId_verificationInput = {
    create?: XOR<UserCreateWithoutId_verificationInput, UserUncheckedCreateWithoutId_verificationInput>
    connectOrCreate?: UserCreateOrConnectWithoutId_verificationInput
    connect?: UserWhereUniqueInput
  }

  export type EnumStatusFieldUpdateOperationsInput = {
    set?: $Enums.Status
  }

  export type EnumdocumentTypeFieldUpdateOperationsInput = {
    set?: $Enums.documentType
  }

  export type UserUpdateOneRequiredWithoutId_verificationNestedInput = {
    create?: XOR<UserCreateWithoutId_verificationInput, UserUncheckedCreateWithoutId_verificationInput>
    connectOrCreate?: UserCreateOrConnectWithoutId_verificationInput
    upsert?: UserUpsertWithoutId_verificationInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutId_verificationInput, UserUpdateWithoutId_verificationInput>, UserUncheckedUpdateWithoutId_verificationInput>
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserCreateNestedOneWithoutEmail_verification_tokenInput = {
    create?: XOR<UserCreateWithoutEmail_verification_tokenInput, UserUncheckedCreateWithoutEmail_verification_tokenInput>
    connectOrCreate?: UserCreateOrConnectWithoutEmail_verification_tokenInput
    connect?: UserWhereUniqueInput
  }

  export type BigIntFieldUpdateOperationsInput = {
    set?: bigint | number
    increment?: bigint | number
    decrement?: bigint | number
    multiply?: bigint | number
    divide?: bigint | number
  }

  export type UserUpdateOneRequiredWithoutEmail_verification_tokenNestedInput = {
    create?: XOR<UserCreateWithoutEmail_verification_tokenInput, UserUncheckedCreateWithoutEmail_verification_tokenInput>
    connectOrCreate?: UserCreateOrConnectWithoutEmail_verification_tokenInput
    upsert?: UserUpsertWithoutEmail_verification_tokenInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEmail_verification_tokenInput, UserUpdateWithoutEmail_verification_tokenInput>, UserUncheckedUpdateWithoutEmail_verification_tokenInput>
  }

  export type UserCreateNestedOneWithoutQuestionsInput = {
    create?: XOR<UserCreateWithoutQuestionsInput, UserUncheckedCreateWithoutQuestionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutQuestionsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutQuestionsNestedInput = {
    create?: XOR<UserCreateWithoutQuestionsInput, UserUncheckedCreateWithoutQuestionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutQuestionsInput
    upsert?: UserUpsertWithoutQuestionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutQuestionsInput, UserUpdateWithoutQuestionsInput>, UserUncheckedUpdateWithoutQuestionsInput>
  }

  export type AppointmentCreateNestedOneWithoutReplyInput = {
    create?: XOR<AppointmentCreateWithoutReplyInput, AppointmentUncheckedCreateWithoutReplyInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutReplyInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutReplyInput = {
    create?: XOR<UserCreateWithoutReplyInput, UserUncheckedCreateWithoutReplyInput>
    connectOrCreate?: UserCreateOrConnectWithoutReplyInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentUpdateOneRequiredWithoutReplyNestedInput = {
    create?: XOR<AppointmentCreateWithoutReplyInput, AppointmentUncheckedCreateWithoutReplyInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutReplyInput
    upsert?: AppointmentUpsertWithoutReplyInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutReplyInput, AppointmentUpdateWithoutReplyInput>, AppointmentUncheckedUpdateWithoutReplyInput>
  }

  export type UserUpdateOneRequiredWithoutReplyNestedInput = {
    create?: XOR<UserCreateWithoutReplyInput, UserUncheckedCreateWithoutReplyInput>
    connectOrCreate?: UserCreateOrConnectWithoutReplyInput
    upsert?: UserUpsertWithoutReplyInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutReplyInput, UserUpdateWithoutReplyInput>, UserUncheckedUpdateWithoutReplyInput>
  }

  export type ExpertCreateNestedOneWithoutStripeAccountInput = {
    create?: XOR<ExpertCreateWithoutStripeAccountInput, ExpertUncheckedCreateWithoutStripeAccountInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutStripeAccountInput
    connect?: ExpertWhereUniqueInput
  }

  export type ExpertUpdateOneRequiredWithoutStripeAccountNestedInput = {
    create?: XOR<ExpertCreateWithoutStripeAccountInput, ExpertUncheckedCreateWithoutStripeAccountInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutStripeAccountInput
    upsert?: ExpertUpsertWithoutStripeAccountInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutStripeAccountInput, ExpertUpdateWithoutStripeAccountInput>, ExpertUncheckedUpdateWithoutStripeAccountInput>
  }

  export type UserCreateNestedOneWithoutKeyInput = {
    create?: XOR<UserCreateWithoutKeyInput, UserUncheckedCreateWithoutKeyInput>
    connectOrCreate?: UserCreateOrConnectWithoutKeyInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutKeyNestedInput = {
    create?: XOR<UserCreateWithoutKeyInput, UserUncheckedCreateWithoutKeyInput>
    connectOrCreate?: UserCreateOrConnectWithoutKeyInput
    upsert?: UserUpsertWithoutKeyInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutKeyInput, UserUpdateWithoutKeyInput>, UserUncheckedUpdateWithoutKeyInput>
  }

  export type UserCreateNestedOneWithoutExperiencesInput = {
    create?: XOR<UserCreateWithoutExperiencesInput, UserUncheckedCreateWithoutExperiencesInput>
    connectOrCreate?: UserCreateOrConnectWithoutExperiencesInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutExperiencesNestedInput = {
    create?: XOR<UserCreateWithoutExperiencesInput, UserUncheckedCreateWithoutExperiencesInput>
    connectOrCreate?: UserCreateOrConnectWithoutExperiencesInput
    upsert?: UserUpsertWithoutExperiencesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutExperiencesInput, UserUpdateWithoutExperiencesInput>, UserUncheckedUpdateWithoutExperiencesInput>
  }

  export type UserCreateNestedOneWithoutEducationsInput = {
    create?: XOR<UserCreateWithoutEducationsInput, UserUncheckedCreateWithoutEducationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEducationsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutEducationsNestedInput = {
    create?: XOR<UserCreateWithoutEducationsInput, UserUncheckedCreateWithoutEducationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEducationsInput
    upsert?: UserUpsertWithoutEducationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEducationsInput, UserUpdateWithoutEducationsInput>, UserUncheckedUpdateWithoutEducationsInput>
  }

  export type UserCreateNestedOneWithoutExpertisesInput = {
    create?: XOR<UserCreateWithoutExpertisesInput, UserUncheckedCreateWithoutExpertisesInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertisesInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutExpertisesNestedInput = {
    create?: XOR<UserCreateWithoutExpertisesInput, UserUncheckedCreateWithoutExpertisesInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertisesInput
    upsert?: UserUpsertWithoutExpertisesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutExpertisesInput, UserUpdateWithoutExpertisesInput>, UserUncheckedUpdateWithoutExpertisesInput>
  }

  export type UserCreateNestedOneWithoutLanguagesSpokenInput = {
    create?: XOR<UserCreateWithoutLanguagesSpokenInput, UserUncheckedCreateWithoutLanguagesSpokenInput>
    connectOrCreate?: UserCreateOrConnectWithoutLanguagesSpokenInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutLanguagesSpokenNestedInput = {
    create?: XOR<UserCreateWithoutLanguagesSpokenInput, UserUncheckedCreateWithoutLanguagesSpokenInput>
    connectOrCreate?: UserCreateOrConnectWithoutLanguagesSpokenInput
    upsert?: UserUpsertWithoutLanguagesSpokenInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutLanguagesSpokenInput, UserUpdateWithoutLanguagesSpokenInput>, UserUncheckedUpdateWithoutLanguagesSpokenInput>
  }

  export type UserCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<UserCreateWithoutAppointmentInput, UserUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentInput
    connect?: UserWhereUniqueInput
  }

  export type ExpertCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ExpertCreateWithoutAppointmentInput, ExpertUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutAppointmentInput
    connect?: ExpertWhereUniqueInput
  }

  export type ClientReviewCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ClientReviewCreateOrConnectWithoutAppointmentInput
    connect?: ClientReviewWhereUniqueInput
  }

  export type ExpertReviewCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutAppointmentInput
    connect?: ExpertReviewWhereUniqueInput
  }

  export type ReplyCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput> | ReplyCreateWithoutAppointmentInput[] | ReplyUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutAppointmentInput | ReplyCreateOrConnectWithoutAppointmentInput[]
    createMany?: ReplyCreateManyAppointmentInputEnvelope
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
  }

  export type ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ClientReviewCreateOrConnectWithoutAppointmentInput
    connect?: ClientReviewWhereUniqueInput
  }

  export type ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutAppointmentInput
    connect?: ExpertReviewWhereUniqueInput
  }

  export type ReplyUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput> | ReplyCreateWithoutAppointmentInput[] | ReplyUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutAppointmentInput | ReplyCreateOrConnectWithoutAppointmentInput[]
    createMany?: ReplyCreateManyAppointmentInputEnvelope
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<UserCreateWithoutAppointmentInput, UserUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentInput
    upsert?: UserUpsertWithoutAppointmentInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAppointmentInput, UserUpdateWithoutAppointmentInput>, UserUncheckedUpdateWithoutAppointmentInput>
  }

  export type ExpertUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<ExpertCreateWithoutAppointmentInput, ExpertUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutAppointmentInput
    upsert?: ExpertUpsertWithoutAppointmentInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutAppointmentInput, ExpertUpdateWithoutAppointmentInput>, ExpertUncheckedUpdateWithoutAppointmentInput>
  }

  export type ClientReviewUpdateOneWithoutAppointmentNestedInput = {
    create?: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ClientReviewCreateOrConnectWithoutAppointmentInput
    upsert?: ClientReviewUpsertWithoutAppointmentInput
    disconnect?: ClientReviewWhereInput | boolean
    delete?: ClientReviewWhereInput | boolean
    connect?: ClientReviewWhereUniqueInput
    update?: XOR<XOR<ClientReviewUpdateToOneWithWhereWithoutAppointmentInput, ClientReviewUpdateWithoutAppointmentInput>, ClientReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ExpertReviewUpdateOneWithoutAppointmentNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutAppointmentInput
    upsert?: ExpertReviewUpsertWithoutAppointmentInput
    disconnect?: ExpertReviewWhereInput | boolean
    delete?: ExpertReviewWhereInput | boolean
    connect?: ExpertReviewWhereUniqueInput
    update?: XOR<XOR<ExpertReviewUpdateToOneWithWhereWithoutAppointmentInput, ExpertReviewUpdateWithoutAppointmentInput>, ExpertReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ReplyUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput> | ReplyCreateWithoutAppointmentInput[] | ReplyUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutAppointmentInput | ReplyCreateOrConnectWithoutAppointmentInput[]
    upsert?: ReplyUpsertWithWhereUniqueWithoutAppointmentInput | ReplyUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: ReplyCreateManyAppointmentInputEnvelope
    set?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    disconnect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    delete?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    update?: ReplyUpdateWithWhereUniqueWithoutAppointmentInput | ReplyUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: ReplyUpdateManyWithWhereWithoutAppointmentInput | ReplyUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
  }

  export type ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput = {
    create?: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ClientReviewCreateOrConnectWithoutAppointmentInput
    upsert?: ClientReviewUpsertWithoutAppointmentInput
    disconnect?: ClientReviewWhereInput | boolean
    delete?: ClientReviewWhereInput | boolean
    connect?: ClientReviewWhereUniqueInput
    update?: XOR<XOR<ClientReviewUpdateToOneWithWhereWithoutAppointmentInput, ClientReviewUpdateWithoutAppointmentInput>, ClientReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput = {
    create?: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ExpertReviewCreateOrConnectWithoutAppointmentInput
    upsert?: ExpertReviewUpsertWithoutAppointmentInput
    disconnect?: ExpertReviewWhereInput | boolean
    delete?: ExpertReviewWhereInput | boolean
    connect?: ExpertReviewWhereUniqueInput
    update?: XOR<XOR<ExpertReviewUpdateToOneWithWhereWithoutAppointmentInput, ExpertReviewUpdateWithoutAppointmentInput>, ExpertReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ReplyUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput> | ReplyCreateWithoutAppointmentInput[] | ReplyUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ReplyCreateOrConnectWithoutAppointmentInput | ReplyCreateOrConnectWithoutAppointmentInput[]
    upsert?: ReplyUpsertWithWhereUniqueWithoutAppointmentInput | ReplyUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: ReplyCreateManyAppointmentInputEnvelope
    set?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    disconnect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    delete?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    connect?: ReplyWhereUniqueInput | ReplyWhereUniqueInput[]
    update?: ReplyUpdateWithWhereUniqueWithoutAppointmentInput | ReplyUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: ReplyUpdateManyWithWhereWithoutAppointmentInput | ReplyUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
  }

  export type ExpertCreateNestedOneWithoutAvailabilitiesInput = {
    create?: XOR<ExpertCreateWithoutAvailabilitiesInput, ExpertUncheckedCreateWithoutAvailabilitiesInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutAvailabilitiesInput
    connect?: ExpertWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutAvailabilitiesInput = {
    create?: XOR<UserCreateWithoutAvailabilitiesInput, UserUncheckedCreateWithoutAvailabilitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAvailabilitiesInput
    connect?: UserWhereUniqueInput
  }

  export type SlotCreateNestedManyWithoutAvailabilityInput = {
    create?: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput> | SlotCreateWithoutAvailabilityInput[] | SlotUncheckedCreateWithoutAvailabilityInput[]
    connectOrCreate?: SlotCreateOrConnectWithoutAvailabilityInput | SlotCreateOrConnectWithoutAvailabilityInput[]
    createMany?: SlotCreateManyAvailabilityInputEnvelope
    connect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
  }

  export type SlotUncheckedCreateNestedManyWithoutAvailabilityInput = {
    create?: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput> | SlotCreateWithoutAvailabilityInput[] | SlotUncheckedCreateWithoutAvailabilityInput[]
    connectOrCreate?: SlotCreateOrConnectWithoutAvailabilityInput | SlotCreateOrConnectWithoutAvailabilityInput[]
    createMany?: SlotCreateManyAvailabilityInputEnvelope
    connect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
  }

  export type ExpertUpdateOneRequiredWithoutAvailabilitiesNestedInput = {
    create?: XOR<ExpertCreateWithoutAvailabilitiesInput, ExpertUncheckedCreateWithoutAvailabilitiesInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutAvailabilitiesInput
    upsert?: ExpertUpsertWithoutAvailabilitiesInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutAvailabilitiesInput, ExpertUpdateWithoutAvailabilitiesInput>, ExpertUncheckedUpdateWithoutAvailabilitiesInput>
  }

  export type UserUpdateOneWithoutAvailabilitiesNestedInput = {
    create?: XOR<UserCreateWithoutAvailabilitiesInput, UserUncheckedCreateWithoutAvailabilitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAvailabilitiesInput
    upsert?: UserUpsertWithoutAvailabilitiesInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAvailabilitiesInput, UserUpdateWithoutAvailabilitiesInput>, UserUncheckedUpdateWithoutAvailabilitiesInput>
  }

  export type SlotUpdateManyWithoutAvailabilityNestedInput = {
    create?: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput> | SlotCreateWithoutAvailabilityInput[] | SlotUncheckedCreateWithoutAvailabilityInput[]
    connectOrCreate?: SlotCreateOrConnectWithoutAvailabilityInput | SlotCreateOrConnectWithoutAvailabilityInput[]
    upsert?: SlotUpsertWithWhereUniqueWithoutAvailabilityInput | SlotUpsertWithWhereUniqueWithoutAvailabilityInput[]
    createMany?: SlotCreateManyAvailabilityInputEnvelope
    set?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    disconnect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    delete?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    connect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    update?: SlotUpdateWithWhereUniqueWithoutAvailabilityInput | SlotUpdateWithWhereUniqueWithoutAvailabilityInput[]
    updateMany?: SlotUpdateManyWithWhereWithoutAvailabilityInput | SlotUpdateManyWithWhereWithoutAvailabilityInput[]
    deleteMany?: SlotScalarWhereInput | SlotScalarWhereInput[]
  }

  export type SlotUncheckedUpdateManyWithoutAvailabilityNestedInput = {
    create?: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput> | SlotCreateWithoutAvailabilityInput[] | SlotUncheckedCreateWithoutAvailabilityInput[]
    connectOrCreate?: SlotCreateOrConnectWithoutAvailabilityInput | SlotCreateOrConnectWithoutAvailabilityInput[]
    upsert?: SlotUpsertWithWhereUniqueWithoutAvailabilityInput | SlotUpsertWithWhereUniqueWithoutAvailabilityInput[]
    createMany?: SlotCreateManyAvailabilityInputEnvelope
    set?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    disconnect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    delete?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    connect?: SlotWhereUniqueInput | SlotWhereUniqueInput[]
    update?: SlotUpdateWithWhereUniqueWithoutAvailabilityInput | SlotUpdateWithWhereUniqueWithoutAvailabilityInput[]
    updateMany?: SlotUpdateManyWithWhereWithoutAvailabilityInput | SlotUpdateManyWithWhereWithoutAvailabilityInput[]
    deleteMany?: SlotScalarWhereInput | SlotScalarWhereInput[]
  }

  export type ExceptionCreateNestedManyWithoutSlotInput = {
    create?: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput> | ExceptionCreateWithoutSlotInput[] | ExceptionUncheckedCreateWithoutSlotInput[]
    connectOrCreate?: ExceptionCreateOrConnectWithoutSlotInput | ExceptionCreateOrConnectWithoutSlotInput[]
    createMany?: ExceptionCreateManySlotInputEnvelope
    connect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
  }

  export type AvailabilityCreateNestedOneWithoutSlotsInput = {
    create?: XOR<AvailabilityCreateWithoutSlotsInput, AvailabilityUncheckedCreateWithoutSlotsInput>
    connectOrCreate?: AvailabilityCreateOrConnectWithoutSlotsInput
    connect?: AvailabilityWhereUniqueInput
  }

  export type ExceptionUncheckedCreateNestedManyWithoutSlotInput = {
    create?: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput> | ExceptionCreateWithoutSlotInput[] | ExceptionUncheckedCreateWithoutSlotInput[]
    connectOrCreate?: ExceptionCreateOrConnectWithoutSlotInput | ExceptionCreateOrConnectWithoutSlotInput[]
    createMany?: ExceptionCreateManySlotInputEnvelope
    connect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
  }

  export type ExceptionUpdateManyWithoutSlotNestedInput = {
    create?: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput> | ExceptionCreateWithoutSlotInput[] | ExceptionUncheckedCreateWithoutSlotInput[]
    connectOrCreate?: ExceptionCreateOrConnectWithoutSlotInput | ExceptionCreateOrConnectWithoutSlotInput[]
    upsert?: ExceptionUpsertWithWhereUniqueWithoutSlotInput | ExceptionUpsertWithWhereUniqueWithoutSlotInput[]
    createMany?: ExceptionCreateManySlotInputEnvelope
    set?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    disconnect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    delete?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    connect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    update?: ExceptionUpdateWithWhereUniqueWithoutSlotInput | ExceptionUpdateWithWhereUniqueWithoutSlotInput[]
    updateMany?: ExceptionUpdateManyWithWhereWithoutSlotInput | ExceptionUpdateManyWithWhereWithoutSlotInput[]
    deleteMany?: ExceptionScalarWhereInput | ExceptionScalarWhereInput[]
  }

  export type AvailabilityUpdateOneRequiredWithoutSlotsNestedInput = {
    create?: XOR<AvailabilityCreateWithoutSlotsInput, AvailabilityUncheckedCreateWithoutSlotsInput>
    connectOrCreate?: AvailabilityCreateOrConnectWithoutSlotsInput
    upsert?: AvailabilityUpsertWithoutSlotsInput
    connect?: AvailabilityWhereUniqueInput
    update?: XOR<XOR<AvailabilityUpdateToOneWithWhereWithoutSlotsInput, AvailabilityUpdateWithoutSlotsInput>, AvailabilityUncheckedUpdateWithoutSlotsInput>
  }

  export type ExceptionUncheckedUpdateManyWithoutSlotNestedInput = {
    create?: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput> | ExceptionCreateWithoutSlotInput[] | ExceptionUncheckedCreateWithoutSlotInput[]
    connectOrCreate?: ExceptionCreateOrConnectWithoutSlotInput | ExceptionCreateOrConnectWithoutSlotInput[]
    upsert?: ExceptionUpsertWithWhereUniqueWithoutSlotInput | ExceptionUpsertWithWhereUniqueWithoutSlotInput[]
    createMany?: ExceptionCreateManySlotInputEnvelope
    set?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    disconnect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    delete?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    connect?: ExceptionWhereUniqueInput | ExceptionWhereUniqueInput[]
    update?: ExceptionUpdateWithWhereUniqueWithoutSlotInput | ExceptionUpdateWithWhereUniqueWithoutSlotInput[]
    updateMany?: ExceptionUpdateManyWithWhereWithoutSlotInput | ExceptionUpdateManyWithWhereWithoutSlotInput[]
    deleteMany?: ExceptionScalarWhereInput | ExceptionScalarWhereInput[]
  }

  export type SlotCreateNestedOneWithoutExceptionsInput = {
    create?: XOR<SlotCreateWithoutExceptionsInput, SlotUncheckedCreateWithoutExceptionsInput>
    connectOrCreate?: SlotCreateOrConnectWithoutExceptionsInput
    connect?: SlotWhereUniqueInput
  }

  export type SlotUpdateOneRequiredWithoutExceptionsNestedInput = {
    create?: XOR<SlotCreateWithoutExceptionsInput, SlotUncheckedCreateWithoutExceptionsInput>
    connectOrCreate?: SlotCreateOrConnectWithoutExceptionsInput
    upsert?: SlotUpsertWithoutExceptionsInput
    connect?: SlotWhereUniqueInput
    update?: XOR<XOR<SlotUpdateToOneWithWhereWithoutExceptionsInput, SlotUpdateWithoutExceptionsInput>, SlotUncheckedUpdateWithoutExceptionsInput>
  }

  export type UserCreateNestedOneWithoutChatInput = {
    create?: XOR<UserCreateWithoutChatInput, UserUncheckedCreateWithoutChatInput>
    connectOrCreate?: UserCreateOrConnectWithoutChatInput
    connect?: UserWhereUniqueInput
  }

  export type ExpertCreateNestedOneWithoutChatInput = {
    create?: XOR<ExpertCreateWithoutChatInput, ExpertUncheckedCreateWithoutChatInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutChatInput
    connect?: ExpertWhereUniqueInput
  }

  export type ChatMessageCreateNestedManyWithoutChatInput = {
    create?: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput> | ChatMessageCreateWithoutChatInput[] | ChatMessageUncheckedCreateWithoutChatInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutChatInput | ChatMessageCreateOrConnectWithoutChatInput[]
    createMany?: ChatMessageCreateManyChatInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type ChatMessageUncheckedCreateNestedManyWithoutChatInput = {
    create?: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput> | ChatMessageCreateWithoutChatInput[] | ChatMessageUncheckedCreateWithoutChatInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutChatInput | ChatMessageCreateOrConnectWithoutChatInput[]
    createMany?: ChatMessageCreateManyChatInputEnvelope
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutChatNestedInput = {
    create?: XOR<UserCreateWithoutChatInput, UserUncheckedCreateWithoutChatInput>
    connectOrCreate?: UserCreateOrConnectWithoutChatInput
    upsert?: UserUpsertWithoutChatInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutChatInput, UserUpdateWithoutChatInput>, UserUncheckedUpdateWithoutChatInput>
  }

  export type ExpertUpdateOneRequiredWithoutChatNestedInput = {
    create?: XOR<ExpertCreateWithoutChatInput, ExpertUncheckedCreateWithoutChatInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutChatInput
    upsert?: ExpertUpsertWithoutChatInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutChatInput, ExpertUpdateWithoutChatInput>, ExpertUncheckedUpdateWithoutChatInput>
  }

  export type ChatMessageUpdateManyWithoutChatNestedInput = {
    create?: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput> | ChatMessageCreateWithoutChatInput[] | ChatMessageUncheckedCreateWithoutChatInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutChatInput | ChatMessageCreateOrConnectWithoutChatInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutChatInput | ChatMessageUpsertWithWhereUniqueWithoutChatInput[]
    createMany?: ChatMessageCreateManyChatInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutChatInput | ChatMessageUpdateWithWhereUniqueWithoutChatInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutChatInput | ChatMessageUpdateManyWithWhereWithoutChatInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ChatMessageUncheckedUpdateManyWithoutChatNestedInput = {
    create?: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput> | ChatMessageCreateWithoutChatInput[] | ChatMessageUncheckedCreateWithoutChatInput[]
    connectOrCreate?: ChatMessageCreateOrConnectWithoutChatInput | ChatMessageCreateOrConnectWithoutChatInput[]
    upsert?: ChatMessageUpsertWithWhereUniqueWithoutChatInput | ChatMessageUpsertWithWhereUniqueWithoutChatInput[]
    createMany?: ChatMessageCreateManyChatInputEnvelope
    set?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    disconnect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    delete?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    connect?: ChatMessageWhereUniqueInput | ChatMessageWhereUniqueInput[]
    update?: ChatMessageUpdateWithWhereUniqueWithoutChatInput | ChatMessageUpdateWithWhereUniqueWithoutChatInput[]
    updateMany?: ChatMessageUpdateManyWithWhereWithoutChatInput | ChatMessageUpdateManyWithWhereWithoutChatInput[]
    deleteMany?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
  }

  export type ChatCreateNestedOneWithoutMessagesInput = {
    create?: XOR<ChatCreateWithoutMessagesInput, ChatUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: ChatCreateOrConnectWithoutMessagesInput
    connect?: ChatWhereUniqueInput
  }

  export type ExpertCreateNestedOneWithoutChatMessageInput = {
    create?: XOR<ExpertCreateWithoutChatMessageInput, ExpertUncheckedCreateWithoutChatMessageInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutChatMessageInput
    connect?: ExpertWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutMessagesInput = {
    create?: XOR<UserCreateWithoutMessagesInput, UserUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesInput
    connect?: UserWhereUniqueInput
  }

  export type ChatUpdateOneRequiredWithoutMessagesNestedInput = {
    create?: XOR<ChatCreateWithoutMessagesInput, ChatUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: ChatCreateOrConnectWithoutMessagesInput
    upsert?: ChatUpsertWithoutMessagesInput
    connect?: ChatWhereUniqueInput
    update?: XOR<XOR<ChatUpdateToOneWithWhereWithoutMessagesInput, ChatUpdateWithoutMessagesInput>, ChatUncheckedUpdateWithoutMessagesInput>
  }

  export type ExpertUpdateOneWithoutChatMessageNestedInput = {
    create?: XOR<ExpertCreateWithoutChatMessageInput, ExpertUncheckedCreateWithoutChatMessageInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutChatMessageInput
    upsert?: ExpertUpsertWithoutChatMessageInput
    disconnect?: ExpertWhereInput | boolean
    delete?: ExpertWhereInput | boolean
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutChatMessageInput, ExpertUpdateWithoutChatMessageInput>, ExpertUncheckedUpdateWithoutChatMessageInput>
  }

  export type UserUpdateOneRequiredWithoutMessagesNestedInput = {
    create?: XOR<UserCreateWithoutMessagesInput, UserUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesInput
    upsert?: UserUpsertWithoutMessagesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutMessagesInput, UserUpdateWithoutMessagesInput>, UserUncheckedUpdateWithoutMessagesInput>
  }

  export type AppointmentCreateNestedOneWithoutReceivedClientReviewsInput = {
    create?: XOR<AppointmentCreateWithoutReceivedClientReviewsInput, AppointmentUncheckedCreateWithoutReceivedClientReviewsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutReceivedClientReviewsInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutReceivedClientReviewsInput = {
    create?: XOR<UserCreateWithoutReceivedClientReviewsInput, UserUncheckedCreateWithoutReceivedClientReviewsInput>
    connectOrCreate?: UserCreateOrConnectWithoutReceivedClientReviewsInput
    connect?: UserWhereUniqueInput
  }

  export type ExpertCreateNestedOneWithoutClientReviewInput = {
    create?: XOR<ExpertCreateWithoutClientReviewInput, ExpertUncheckedCreateWithoutClientReviewInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutClientReviewInput
    connect?: ExpertWhereUniqueInput
  }

  export type AppointmentUpdateOneRequiredWithoutReceivedClientReviewsNestedInput = {
    create?: XOR<AppointmentCreateWithoutReceivedClientReviewsInput, AppointmentUncheckedCreateWithoutReceivedClientReviewsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutReceivedClientReviewsInput
    upsert?: AppointmentUpsertWithoutReceivedClientReviewsInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutReceivedClientReviewsInput, AppointmentUpdateWithoutReceivedClientReviewsInput>, AppointmentUncheckedUpdateWithoutReceivedClientReviewsInput>
  }

  export type UserUpdateOneRequiredWithoutReceivedClientReviewsNestedInput = {
    create?: XOR<UserCreateWithoutReceivedClientReviewsInput, UserUncheckedCreateWithoutReceivedClientReviewsInput>
    connectOrCreate?: UserCreateOrConnectWithoutReceivedClientReviewsInput
    upsert?: UserUpsertWithoutReceivedClientReviewsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutReceivedClientReviewsInput, UserUpdateWithoutReceivedClientReviewsInput>, UserUncheckedUpdateWithoutReceivedClientReviewsInput>
  }

  export type ExpertUpdateOneRequiredWithoutClientReviewNestedInput = {
    create?: XOR<ExpertCreateWithoutClientReviewInput, ExpertUncheckedCreateWithoutClientReviewInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutClientReviewInput
    upsert?: ExpertUpsertWithoutClientReviewInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutClientReviewInput, ExpertUpdateWithoutClientReviewInput>, ExpertUncheckedUpdateWithoutClientReviewInput>
  }

  export type AppointmentCreateNestedOneWithoutWrittenExpertReviewsInput = {
    create?: XOR<AppointmentCreateWithoutWrittenExpertReviewsInput, AppointmentUncheckedCreateWithoutWrittenExpertReviewsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutWrittenExpertReviewsInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutWrittenExpertReviewsInput = {
    create?: XOR<UserCreateWithoutWrittenExpertReviewsInput, UserUncheckedCreateWithoutWrittenExpertReviewsInput>
    connectOrCreate?: UserCreateOrConnectWithoutWrittenExpertReviewsInput
    connect?: UserWhereUniqueInput
  }

  export type ExpertCreateNestedOneWithoutExpertReviewInput = {
    create?: XOR<ExpertCreateWithoutExpertReviewInput, ExpertUncheckedCreateWithoutExpertReviewInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutExpertReviewInput
    connect?: ExpertWhereUniqueInput
  }

  export type AppointmentUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput = {
    create?: XOR<AppointmentCreateWithoutWrittenExpertReviewsInput, AppointmentUncheckedCreateWithoutWrittenExpertReviewsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutWrittenExpertReviewsInput
    upsert?: AppointmentUpsertWithoutWrittenExpertReviewsInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutWrittenExpertReviewsInput, AppointmentUpdateWithoutWrittenExpertReviewsInput>, AppointmentUncheckedUpdateWithoutWrittenExpertReviewsInput>
  }

  export type UserUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput = {
    create?: XOR<UserCreateWithoutWrittenExpertReviewsInput, UserUncheckedCreateWithoutWrittenExpertReviewsInput>
    connectOrCreate?: UserCreateOrConnectWithoutWrittenExpertReviewsInput
    upsert?: UserUpsertWithoutWrittenExpertReviewsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutWrittenExpertReviewsInput, UserUpdateWithoutWrittenExpertReviewsInput>, UserUncheckedUpdateWithoutWrittenExpertReviewsInput>
  }

  export type ExpertUpdateOneRequiredWithoutExpertReviewNestedInput = {
    create?: XOR<ExpertCreateWithoutExpertReviewInput, ExpertUncheckedCreateWithoutExpertReviewInput>
    connectOrCreate?: ExpertCreateOrConnectWithoutExpertReviewInput
    upsert?: ExpertUpsertWithoutExpertReviewInput
    connect?: ExpertWhereUniqueInput
    update?: XOR<XOR<ExpertUpdateToOneWithWhereWithoutExpertReviewInput, ExpertUpdateWithoutExpertReviewInput>, ExpertUncheckedUpdateWithoutExpertReviewInput>
  }

  export type EnumINVITE_STATUSFieldUpdateOperationsInput = {
    set?: $Enums.INVITE_STATUS
  }

  export type UserCreateNestedOneWithoutAdmin_userInput = {
    create?: XOR<UserCreateWithoutAdmin_userInput, UserUncheckedCreateWithoutAdmin_userInput>
    connectOrCreate?: UserCreateOrConnectWithoutAdmin_userInput
    connect?: UserWhereUniqueInput
  }

  export type NullableEnumAdminRoleFieldUpdateOperationsInput = {
    set?: $Enums.AdminRole | null
  }

  export type UserUpdateOneRequiredWithoutAdmin_userNestedInput = {
    create?: XOR<UserCreateWithoutAdmin_userInput, UserUncheckedCreateWithoutAdmin_userInput>
    connectOrCreate?: UserCreateOrConnectWithoutAdmin_userInput
    upsert?: UserUpsertWithoutAdmin_userInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAdmin_userInput, UserUpdateWithoutAdmin_userInput>, UserUncheckedUpdateWithoutAdmin_userInput>
  }

  export type UserCreateNestedOneWithoutSessionInput = {
    create?: XOR<UserCreateWithoutSessionInput, UserUncheckedCreateWithoutSessionInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutSessionNestedInput = {
    create?: XOR<UserCreateWithoutSessionInput, UserUncheckedCreateWithoutSessionInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionInput
    upsert?: UserUpsertWithoutSessionInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionInput, UserUpdateWithoutSessionInput>, UserUncheckedUpdateWithoutSessionInput>
  }

  export type EnumNotificationStatusFieldUpdateOperationsInput = {
    set?: $Enums.NotificationStatus
  }

  export type admin_expert_applicationCreateNestedOneWithoutAnswerInput = {
    create?: XOR<admin_expert_applicationCreateWithoutAnswerInput, admin_expert_applicationUncheckedCreateWithoutAnswerInput>
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutAnswerInput
    connect?: admin_expert_applicationWhereUniqueInput
  }

  export type expertApplicationQuestionCreateNestedOneWithoutExpertApplicationAnswerInput = {
    create?: XOR<expertApplicationQuestionCreateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedCreateWithoutExpertApplicationAnswerInput>
    connectOrCreate?: expertApplicationQuestionCreateOrConnectWithoutExpertApplicationAnswerInput
    connect?: expertApplicationQuestionWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutExpertApplicationAnswerInput = {
    create?: XOR<UserCreateWithoutExpertApplicationAnswerInput, UserUncheckedCreateWithoutExpertApplicationAnswerInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertApplicationAnswerInput
    connect?: UserWhereUniqueInput
  }

  export type admin_expert_applicationUpdateOneWithoutAnswerNestedInput = {
    create?: XOR<admin_expert_applicationCreateWithoutAnswerInput, admin_expert_applicationUncheckedCreateWithoutAnswerInput>
    connectOrCreate?: admin_expert_applicationCreateOrConnectWithoutAnswerInput
    upsert?: admin_expert_applicationUpsertWithoutAnswerInput
    disconnect?: admin_expert_applicationWhereInput | boolean
    delete?: admin_expert_applicationWhereInput | boolean
    connect?: admin_expert_applicationWhereUniqueInput
    update?: XOR<XOR<admin_expert_applicationUpdateToOneWithWhereWithoutAnswerInput, admin_expert_applicationUpdateWithoutAnswerInput>, admin_expert_applicationUncheckedUpdateWithoutAnswerInput>
  }

  export type expertApplicationQuestionUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput = {
    create?: XOR<expertApplicationQuestionCreateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedCreateWithoutExpertApplicationAnswerInput>
    connectOrCreate?: expertApplicationQuestionCreateOrConnectWithoutExpertApplicationAnswerInput
    upsert?: expertApplicationQuestionUpsertWithoutExpertApplicationAnswerInput
    connect?: expertApplicationQuestionWhereUniqueInput
    update?: XOR<XOR<expertApplicationQuestionUpdateToOneWithWhereWithoutExpertApplicationAnswerInput, expertApplicationQuestionUpdateWithoutExpertApplicationAnswerInput>, expertApplicationQuestionUncheckedUpdateWithoutExpertApplicationAnswerInput>
  }

  export type UserUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput = {
    create?: XOR<UserCreateWithoutExpertApplicationAnswerInput, UserUncheckedCreateWithoutExpertApplicationAnswerInput>
    connectOrCreate?: UserCreateOrConnectWithoutExpertApplicationAnswerInput
    upsert?: UserUpsertWithoutExpertApplicationAnswerInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutExpertApplicationAnswerInput, UserUpdateWithoutExpertApplicationAnswerInput>, UserUncheckedUpdateWithoutExpertApplicationAnswerInput>
  }

  export type UserCreateNestedOneWithoutAdmin_expert_applicationInput = {
    create?: XOR<UserCreateWithoutAdmin_expert_applicationInput, UserUncheckedCreateWithoutAdmin_expert_applicationInput>
    connectOrCreate?: UserCreateOrConnectWithoutAdmin_expert_applicationInput
    connect?: UserWhereUniqueInput
  }

  export type expertApplicationAnswerCreateNestedManyWithoutAdmin_expert_applicationInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput> | expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput[] | expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput | expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput[]
    createMany?: expertApplicationAnswerCreateManyAdmin_expert_applicationInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type expertApplicationAnswerUncheckedCreateNestedManyWithoutAdmin_expert_applicationInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput> | expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput[] | expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput | expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput[]
    createMany?: expertApplicationAnswerCreateManyAdmin_expert_applicationInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutAdmin_expert_applicationNestedInput = {
    create?: XOR<UserCreateWithoutAdmin_expert_applicationInput, UserUncheckedCreateWithoutAdmin_expert_applicationInput>
    connectOrCreate?: UserCreateOrConnectWithoutAdmin_expert_applicationInput
    upsert?: UserUpsertWithoutAdmin_expert_applicationInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAdmin_expert_applicationInput, UserUpdateWithoutAdmin_expert_applicationInput>, UserUncheckedUpdateWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerUpdateManyWithoutAdmin_expert_applicationNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput> | expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput[] | expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput | expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutAdmin_expert_applicationInput[]
    createMany?: expertApplicationAnswerCreateManyAdmin_expert_applicationInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutAdmin_expert_applicationInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpdateManyWithWhereWithoutAdmin_expert_applicationInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutAdmin_expert_applicationNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput> | expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput[] | expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput | expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutAdmin_expert_applicationInput[]
    createMany?: expertApplicationAnswerCreateManyAdmin_expert_applicationInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutAdmin_expert_applicationInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutAdmin_expert_applicationInput | expertApplicationAnswerUpdateManyWithWhereWithoutAdmin_expert_applicationInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type expertApplicationAnswerCreateNestedManyWithoutExpertApplicationQuestionInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput> | expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput[] | expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput | expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput[]
    createMany?: expertApplicationAnswerCreateManyExpertApplicationQuestionInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type expertApplicationAnswerUncheckedCreateNestedManyWithoutExpertApplicationQuestionInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput> | expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput[] | expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput | expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput[]
    createMany?: expertApplicationAnswerCreateManyExpertApplicationQuestionInputEnvelope
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
  }

  export type expertApplicationAnswerUpdateManyWithoutExpertApplicationQuestionNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput> | expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput[] | expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput | expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutExpertApplicationQuestionInput[]
    createMany?: expertApplicationAnswerCreateManyExpertApplicationQuestionInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutExpertApplicationQuestionInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpdateManyWithWhereWithoutExpertApplicationQuestionInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutExpertApplicationQuestionNestedInput = {
    create?: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput> | expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput[] | expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput[]
    connectOrCreate?: expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput | expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput[]
    upsert?: expertApplicationAnswerUpsertWithWhereUniqueWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpsertWithWhereUniqueWithoutExpertApplicationQuestionInput[]
    createMany?: expertApplicationAnswerCreateManyExpertApplicationQuestionInputEnvelope
    set?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    disconnect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    delete?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    connect?: expertApplicationAnswerWhereUniqueInput | expertApplicationAnswerWhereUniqueInput[]
    update?: expertApplicationAnswerUpdateWithWhereUniqueWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpdateWithWhereUniqueWithoutExpertApplicationQuestionInput[]
    updateMany?: expertApplicationAnswerUpdateManyWithWhereWithoutExpertApplicationQuestionInput | expertApplicationAnswerUpdateManyWithWhereWithoutExpertApplicationQuestionInput[]
    deleteMany?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedEnumCountryCodeFilter<$PrismaModel = never> = {
    equals?: $Enums.CountryCode | EnumCountryCodeFieldRefInput<$PrismaModel>
    in?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    notIn?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    not?: NestedEnumCountryCodeFilter<$PrismaModel> | $Enums.CountryCode
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | 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 NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    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[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | 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[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    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 NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }
  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[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumCountryCodeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CountryCode | EnumCountryCodeFieldRefInput<$PrismaModel>
    in?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    notIn?: $Enums.CountryCode[] | ListEnumCountryCodeFieldRefInput<$PrismaModel>
    not?: NestedEnumCountryCodeWithAggregatesFilter<$PrismaModel> | $Enums.CountryCode
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCountryCodeFilter<$PrismaModel>
    _max?: NestedEnumCountryCodeFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | 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 NestedEnumStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.Status | EnumStatusFieldRefInput<$PrismaModel>
    in?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStatusFilter<$PrismaModel> | $Enums.Status
  }

  export type NestedEnumdocumentTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.documentType | EnumdocumentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumdocumentTypeFilter<$PrismaModel> | $Enums.documentType
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    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[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedEnumStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Status | EnumStatusFieldRefInput<$PrismaModel>
    in?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.Status[] | ListEnumStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStatusWithAggregatesFilter<$PrismaModel> | $Enums.Status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusFilter<$PrismaModel>
    _max?: NestedEnumStatusFilter<$PrismaModel>
  }

  export type NestedEnumdocumentTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.documentType | EnumdocumentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.documentType[] | ListEnumdocumentTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumdocumentTypeWithAggregatesFilter<$PrismaModel> | $Enums.documentType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumdocumentTypeFilter<$PrismaModel>
    _max?: NestedEnumdocumentTypeFilter<$PrismaModel>
  }

  export type NestedBigIntFilter<$PrismaModel = never> = {
    equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    not?: NestedBigIntFilter<$PrismaModel> | bigint | number
  }

  export type NestedBigIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
    lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
    not?: NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedBigIntFilter<$PrismaModel>
    _min?: NestedBigIntFilter<$PrismaModel>
    _max?: NestedBigIntFilter<$PrismaModel>
  }
  export type NestedJsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumINVITE_STATUSFilter<$PrismaModel = never> = {
    equals?: $Enums.INVITE_STATUS | EnumINVITE_STATUSFieldRefInput<$PrismaModel>
    in?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    notIn?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    not?: NestedEnumINVITE_STATUSFilter<$PrismaModel> | $Enums.INVITE_STATUS
  }

  export type NestedEnumINVITE_STATUSWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.INVITE_STATUS | EnumINVITE_STATUSFieldRefInput<$PrismaModel>
    in?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    notIn?: $Enums.INVITE_STATUS[] | ListEnumINVITE_STATUSFieldRefInput<$PrismaModel>
    not?: NestedEnumINVITE_STATUSWithAggregatesFilter<$PrismaModel> | $Enums.INVITE_STATUS
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumINVITE_STATUSFilter<$PrismaModel>
    _max?: NestedEnumINVITE_STATUSFilter<$PrismaModel>
  }

  export type NestedEnumAdminRoleNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAdminRoleNullableFilter<$PrismaModel> | $Enums.AdminRole | null
  }

  export type NestedEnumAdminRoleNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAdminRoleNullableWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAdminRoleNullableFilter<$PrismaModel>
    _max?: NestedEnumAdminRoleNullableFilter<$PrismaModel>
  }

  export type NestedEnumNotificationStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationStatus | EnumNotificationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationStatusFilter<$PrismaModel> | $Enums.NotificationStatus
  }

  export type NestedEnumNotificationStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationStatus | EnumNotificationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationStatus[] | ListEnumNotificationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationStatusWithAggregatesFilter<$PrismaModel> | $Enums.NotificationStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumNotificationStatusFilter<$PrismaModel>
    _max?: NestedEnumNotificationStatusFilter<$PrismaModel>
  }

  export type AppointmentCreateWithoutClientInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    expert: ExpertCreateNestedOneWithoutAppointmentInput
    receivedClientReviews?: ClientReviewCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewCreateNestedOneWithoutAppointmentInput
    reply?: ReplyCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutClientInput = {
    id?: number
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    receivedClientReviews?: ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput
    reply?: ReplyUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutClientInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput>
  }

  export type AppointmentCreateManyClientInputEnvelope = {
    data: AppointmentCreateManyClientInput | AppointmentCreateManyClientInput[]
    skipDuplicates?: boolean
  }

  export type AvailabilityCreateWithoutUserInput = {
    day: string
    timezone: string
    expert: ExpertCreateNestedOneWithoutAvailabilitiesInput
    slots?: SlotCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityUncheckedCreateWithoutUserInput = {
    id?: number
    day: string
    timezone: string
    expertId: string
    slots?: SlotUncheckedCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityCreateOrConnectWithoutUserInput = {
    where: AvailabilityWhereUniqueInput
    create: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput>
  }

  export type AvailabilityCreateManyUserInputEnvelope = {
    data: AvailabilityCreateManyUserInput | AvailabilityCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ChatCreateWithoutClientInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    expert: ExpertCreateNestedOneWithoutChatInput
    messages?: ChatMessageCreateNestedManyWithoutChatInput
  }

  export type ChatUncheckedCreateWithoutClientInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    expertId: string
    messages?: ChatMessageUncheckedCreateNestedManyWithoutChatInput
  }

  export type ChatCreateOrConnectWithoutClientInput = {
    where: ChatWhereUniqueInput
    create: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput>
  }

  export type ChatCreateManyClientInputEnvelope = {
    data: ChatCreateManyClientInput | ChatCreateManyClientInput[]
    skipDuplicates?: boolean
  }

  export type ChatMessageCreateWithoutSenderInput = {
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chat: ChatCreateNestedOneWithoutMessagesInput
    Expert?: ExpertCreateNestedOneWithoutChatMessageInput
  }

  export type ChatMessageUncheckedCreateWithoutSenderInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    expertId?: string | null
  }

  export type ChatMessageCreateOrConnectWithoutSenderInput = {
    where: ChatMessageWhereUniqueInput
    create: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput>
  }

  export type ChatMessageCreateManySenderInputEnvelope = {
    data: ChatMessageCreateManySenderInput | ChatMessageCreateManySenderInput[]
    skipDuplicates?: boolean
  }

  export type ClientReviewCreateWithoutClientInput = {
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutReceivedClientReviewsInput
    expert: ExpertCreateNestedOneWithoutClientReviewInput
  }

  export type ClientReviewUncheckedCreateWithoutClientInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    expertId: string
  }

  export type ClientReviewCreateOrConnectWithoutClientInput = {
    where: ClientReviewWhereUniqueInput
    create: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput>
  }

  export type ClientReviewCreateManyClientInputEnvelope = {
    data: ClientReviewCreateManyClientInput | ClientReviewCreateManyClientInput[]
    skipDuplicates?: boolean
  }

  export type EducationCreateWithoutUserInput = {
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type EducationUncheckedCreateWithoutUserInput = {
    id?: number
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type EducationCreateOrConnectWithoutUserInput = {
    where: EducationWhereUniqueInput
    create: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput>
  }

  export type EducationCreateManyUserInputEnvelope = {
    data: EducationCreateManyUserInput | EducationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ExperienceCreateWithoutUserInput = {
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    endDate?: Date | string | null
    startDate?: Date | string | null
  }

  export type ExperienceUncheckedCreateWithoutUserInput = {
    id?: number
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    endDate?: Date | string | null
    startDate?: Date | string | null
  }

  export type ExperienceCreateOrConnectWithoutUserInput = {
    where: ExperienceWhereUniqueInput
    create: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput>
  }

  export type ExperienceCreateManyUserInputEnvelope = {
    data: ExperienceCreateManyUserInput | ExperienceCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ExpertCreateWithoutUserInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutUserInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutUserInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
  }

  export type ExpertReviewCreateWithoutClientInput = {
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutWrittenExpertReviewsInput
    expert: ExpertCreateNestedOneWithoutExpertReviewInput
  }

  export type ExpertReviewUncheckedCreateWithoutClientInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    expertId: string
    appointmentKey: string
    isDisplayed?: boolean
  }

  export type ExpertReviewCreateOrConnectWithoutClientInput = {
    where: ExpertReviewWhereUniqueInput
    create: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput>
  }

  export type ExpertReviewCreateManyClientInputEnvelope = {
    data: ExpertReviewCreateManyClientInput | ExpertReviewCreateManyClientInput[]
    skipDuplicates?: boolean
  }

  export type ExpertiseCreateWithoutUserInput = {
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type ExpertiseUncheckedCreateWithoutUserInput = {
    id?: number
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type ExpertiseCreateOrConnectWithoutUserInput = {
    where: ExpertiseWhereUniqueInput
    create: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput>
  }

  export type ExpertiseCreateManyUserInputEnvelope = {
    data: ExpertiseCreateManyUserInput | ExpertiseCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type KeyCreateWithoutUserInput = {
    id: string
    hashed_password?: string | null
  }

  export type KeyUncheckedCreateWithoutUserInput = {
    id: string
    hashed_password?: string | null
  }

  export type KeyCreateOrConnectWithoutUserInput = {
    where: KeyWhereUniqueInput
    create: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput>
  }

  export type KeyCreateManyUserInputEnvelope = {
    data: KeyCreateManyUserInput | KeyCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type LanguageCreateWithoutUserInput = {
    name?: string
  }

  export type LanguageUncheckedCreateWithoutUserInput = {
    id?: number
    name?: string
  }

  export type LanguageCreateOrConnectWithoutUserInput = {
    where: LanguageWhereUniqueInput
    create: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput>
  }

  export type LanguageCreateManyUserInputEnvelope = {
    data: LanguageCreateManyUserInput | LanguageCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type QuestionCreateWithoutUserInput = {
    content: string
  }

  export type QuestionUncheckedCreateWithoutUserInput = {
    id?: number
    content: string
  }

  export type QuestionCreateOrConnectWithoutUserInput = {
    where: QuestionWhereUniqueInput
    create: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput>
  }

  export type QuestionCreateManyUserInputEnvelope = {
    data: QuestionCreateManyUserInput | QuestionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ReplyCreateWithoutUserInput = {
    content: string
    questionContent: string
    appointment: AppointmentCreateNestedOneWithoutReplyInput
  }

  export type ReplyUncheckedCreateWithoutUserInput = {
    id?: number
    content: string
    appointmentKey: string
    questionContent: string
  }

  export type ReplyCreateOrConnectWithoutUserInput = {
    where: ReplyWhereUniqueInput
    create: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput>
  }

  export type ReplyCreateManyUserInputEnvelope = {
    data: ReplyCreateManyUserInput | ReplyCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type admin_expert_applicationCreateWithoutUserInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    answer?: expertApplicationAnswerCreateNestedManyWithoutAdmin_expert_applicationInput
  }

  export type admin_expert_applicationUncheckedCreateWithoutUserInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    answer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutAdmin_expert_applicationInput
  }

  export type admin_expert_applicationCreateOrConnectWithoutUserInput = {
    where: admin_expert_applicationWhereUniqueInput
    create: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput>
  }

  export type admin_expert_applicationCreateManyUserInputEnvelope = {
    data: admin_expert_applicationCreateManyUserInput | admin_expert_applicationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type admin_userCreateWithoutUserInput = {
    id: string
    created_at?: Date | string
    role?: $Enums.AdminRole | null
  }

  export type admin_userUncheckedCreateWithoutUserInput = {
    id: string
    created_at?: Date | string
    role?: $Enums.AdminRole | null
  }

  export type admin_userCreateOrConnectWithoutUserInput = {
    where: admin_userWhereUniqueInput
    create: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
  }

  export type email_verification_tokenCreateWithoutUserInput = {
    id: string
    expires: bigint | number
  }

  export type email_verification_tokenUncheckedCreateWithoutUserInput = {
    id: string
    expires: bigint | number
  }

  export type email_verification_tokenCreateOrConnectWithoutUserInput = {
    where: email_verification_tokenWhereUniqueInput
    create: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput>
  }

  export type email_verification_tokenCreateManyUserInputEnvelope = {
    data: email_verification_tokenCreateManyUserInput | email_verification_tokenCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type expertApplicationAnswerCreateWithoutUserInput = {
    id?: string
    answer: string
    created_at?: Date | string
    admin_expert_application?: admin_expert_applicationCreateNestedOneWithoutAnswerInput
    expertApplicationQuestion: expertApplicationQuestionCreateNestedOneWithoutExpertApplicationAnswerInput
  }

  export type expertApplicationAnswerUncheckedCreateWithoutUserInput = {
    id?: string
    answer: string
    created_at?: Date | string
    questionId: string
    admin_expert_applicationId?: string | null
  }

  export type expertApplicationAnswerCreateOrConnectWithoutUserInput = {
    where: expertApplicationAnswerWhereUniqueInput
    create: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput>
  }

  export type expertApplicationAnswerCreateManyUserInputEnvelope = {
    data: expertApplicationAnswerCreateManyUserInput | expertApplicationAnswerCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type id_verificationCreateWithoutUserInput = {
    status?: $Enums.Status
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
  }

  export type id_verificationUncheckedCreateWithoutUserInput = {
    id?: number
    status?: $Enums.Status
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
  }

  export type id_verificationCreateOrConnectWithoutUserInput = {
    where: id_verificationWhereUniqueInput
    create: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput>
  }

  export type id_verificationCreateManyUserInputEnvelope = {
    data: id_verificationCreateManyUserInput | id_verificationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type sessionCreateWithoutUserInput = {
    id: string
    active_expires: bigint | number
    idle_expires: bigint | number
  }

  export type sessionUncheckedCreateWithoutUserInput = {
    id: string
    active_expires: bigint | number
    idle_expires: bigint | number
  }

  export type sessionCreateOrConnectWithoutUserInput = {
    where: sessionWhereUniqueInput
    create: XOR<sessionCreateWithoutUserInput, sessionUncheckedCreateWithoutUserInput>
  }

  export type sessionCreateManyUserInputEnvelope = {
    data: sessionCreateManyUserInput | sessionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentUpsertWithWhereUniqueWithoutClientInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutClientInput, AppointmentUncheckedUpdateWithoutClientInput>
    create: XOR<AppointmentCreateWithoutClientInput, AppointmentUncheckedCreateWithoutClientInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutClientInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutClientInput, AppointmentUncheckedUpdateWithoutClientInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutClientInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutClientInput>
  }

  export type AppointmentScalarWhereInput = {
    AND?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    OR?: AppointmentScalarWhereInput[]
    NOT?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    id?: IntFilter<"Appointment"> | number
    clientId?: StringFilter<"Appointment"> | string
    clientEmail?: StringFilter<"Appointment"> | string
    expertId?: StringFilter<"Appointment"> | string
    clientName?: StringFilter<"Appointment"> | string
    expertName?: StringFilter<"Appointment"> | string
    isAcceptedByExpert?: StringFilter<"Appointment"> | string
    price?: StringFilter<"Appointment"> | string
    timezone?: StringFilter<"Appointment"> | string
    date?: IntFilter<"Appointment"> | number
    dayName?: StringFilter<"Appointment"> | string
    time?: StringFilter<"Appointment"> | string
    text?: StringNullableFilter<"Appointment"> | string | null
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    videoRoomId?: StringFilter<"Appointment"> | string
    appointmentKey?: StringFilter<"Appointment"> | string
    paymentStatus?: StringFilter<"Appointment"> | string
    paymentIntentId?: StringFilter<"Appointment"> | string
    sessionId?: StringFilter<"Appointment"> | string
    authorizedDate?: StringFilter<"Appointment"> | string
    appointementKeyInExpertTimeZone?: StringFilter<"Appointment"> | string
    appointementKeyInClientTimeZone?: StringFilter<"Appointment"> | string
    bookedAppointments?: JsonNullableFilter<"Appointment">
    status?: StringFilter<"Appointment"> | string
    reason?: StringNullableFilter<"Appointment"> | string | null
  }

  export type AvailabilityUpsertWithWhereUniqueWithoutUserInput = {
    where: AvailabilityWhereUniqueInput
    update: XOR<AvailabilityUpdateWithoutUserInput, AvailabilityUncheckedUpdateWithoutUserInput>
    create: XOR<AvailabilityCreateWithoutUserInput, AvailabilityUncheckedCreateWithoutUserInput>
  }

  export type AvailabilityUpdateWithWhereUniqueWithoutUserInput = {
    where: AvailabilityWhereUniqueInput
    data: XOR<AvailabilityUpdateWithoutUserInput, AvailabilityUncheckedUpdateWithoutUserInput>
  }

  export type AvailabilityUpdateManyWithWhereWithoutUserInput = {
    where: AvailabilityScalarWhereInput
    data: XOR<AvailabilityUpdateManyMutationInput, AvailabilityUncheckedUpdateManyWithoutUserInput>
  }

  export type AvailabilityScalarWhereInput = {
    AND?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
    OR?: AvailabilityScalarWhereInput[]
    NOT?: AvailabilityScalarWhereInput | AvailabilityScalarWhereInput[]
    id?: IntFilter<"Availability"> | number
    day?: StringFilter<"Availability"> | string
    timezone?: StringFilter<"Availability"> | string
    expertId?: StringFilter<"Availability"> | string
    userId?: StringNullableFilter<"Availability"> | string | null
  }

  export type ChatUpsertWithWhereUniqueWithoutClientInput = {
    where: ChatWhereUniqueInput
    update: XOR<ChatUpdateWithoutClientInput, ChatUncheckedUpdateWithoutClientInput>
    create: XOR<ChatCreateWithoutClientInput, ChatUncheckedCreateWithoutClientInput>
  }

  export type ChatUpdateWithWhereUniqueWithoutClientInput = {
    where: ChatWhereUniqueInput
    data: XOR<ChatUpdateWithoutClientInput, ChatUncheckedUpdateWithoutClientInput>
  }

  export type ChatUpdateManyWithWhereWithoutClientInput = {
    where: ChatScalarWhereInput
    data: XOR<ChatUpdateManyMutationInput, ChatUncheckedUpdateManyWithoutClientInput>
  }

  export type ChatScalarWhereInput = {
    AND?: ChatScalarWhereInput | ChatScalarWhereInput[]
    OR?: ChatScalarWhereInput[]
    NOT?: ChatScalarWhereInput | ChatScalarWhereInput[]
    id?: StringFilter<"Chat"> | string
    createdAt?: DateTimeFilter<"Chat"> | Date | string
    updatedAt?: DateTimeFilter<"Chat"> | Date | string
    clientId?: StringFilter<"Chat"> | string
    expertId?: StringFilter<"Chat"> | string
  }

  export type ChatMessageUpsertWithWhereUniqueWithoutSenderInput = {
    where: ChatMessageWhereUniqueInput
    update: XOR<ChatMessageUpdateWithoutSenderInput, ChatMessageUncheckedUpdateWithoutSenderInput>
    create: XOR<ChatMessageCreateWithoutSenderInput, ChatMessageUncheckedCreateWithoutSenderInput>
  }

  export type ChatMessageUpdateWithWhereUniqueWithoutSenderInput = {
    where: ChatMessageWhereUniqueInput
    data: XOR<ChatMessageUpdateWithoutSenderInput, ChatMessageUncheckedUpdateWithoutSenderInput>
  }

  export type ChatMessageUpdateManyWithWhereWithoutSenderInput = {
    where: ChatMessageScalarWhereInput
    data: XOR<ChatMessageUpdateManyMutationInput, ChatMessageUncheckedUpdateManyWithoutSenderInput>
  }

  export type ChatMessageScalarWhereInput = {
    AND?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
    OR?: ChatMessageScalarWhereInput[]
    NOT?: ChatMessageScalarWhereInput | ChatMessageScalarWhereInput[]
    id?: IntFilter<"ChatMessage"> | number
    content?: StringFilter<"ChatMessage"> | string
    userId?: StringFilter<"ChatMessage"> | string
    fileName?: StringFilter<"ChatMessage"> | string
    type?: StringFilter<"ChatMessage"> | string
    fileType?: StringFilter<"ChatMessage"> | string
    fileUrl?: StringFilter<"ChatMessage"> | string
    createdAt?: DateTimeFilter<"ChatMessage"> | Date | string
    chatId?: StringFilter<"ChatMessage"> | string
    senderId?: StringFilter<"ChatMessage"> | string
    expertId?: StringNullableFilter<"ChatMessage"> | string | null
  }

  export type ClientReviewUpsertWithWhereUniqueWithoutClientInput = {
    where: ClientReviewWhereUniqueInput
    update: XOR<ClientReviewUpdateWithoutClientInput, ClientReviewUncheckedUpdateWithoutClientInput>
    create: XOR<ClientReviewCreateWithoutClientInput, ClientReviewUncheckedCreateWithoutClientInput>
  }

  export type ClientReviewUpdateWithWhereUniqueWithoutClientInput = {
    where: ClientReviewWhereUniqueInput
    data: XOR<ClientReviewUpdateWithoutClientInput, ClientReviewUncheckedUpdateWithoutClientInput>
  }

  export type ClientReviewUpdateManyWithWhereWithoutClientInput = {
    where: ClientReviewScalarWhereInput
    data: XOR<ClientReviewUpdateManyMutationInput, ClientReviewUncheckedUpdateManyWithoutClientInput>
  }

  export type ClientReviewScalarWhereInput = {
    AND?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
    OR?: ClientReviewScalarWhereInput[]
    NOT?: ClientReviewScalarWhereInput | ClientReviewScalarWhereInput[]
    id?: IntFilter<"ClientReview"> | number
    reviewText?: StringFilter<"ClientReview"> | string
    createdAt?: DateTimeFilter<"ClientReview"> | Date | string
    videoRoomId?: StringFilter<"ClientReview"> | string
    appointmentKey?: StringFilter<"ClientReview"> | string
    isDisplayed?: BoolFilter<"ClientReview"> | boolean
    clientId?: StringFilter<"ClientReview"> | string
    expertId?: StringFilter<"ClientReview"> | string
  }

  export type EducationUpsertWithWhereUniqueWithoutUserInput = {
    where: EducationWhereUniqueInput
    update: XOR<EducationUpdateWithoutUserInput, EducationUncheckedUpdateWithoutUserInput>
    create: XOR<EducationCreateWithoutUserInput, EducationUncheckedCreateWithoutUserInput>
  }

  export type EducationUpdateWithWhereUniqueWithoutUserInput = {
    where: EducationWhereUniqueInput
    data: XOR<EducationUpdateWithoutUserInput, EducationUncheckedUpdateWithoutUserInput>
  }

  export type EducationUpdateManyWithWhereWithoutUserInput = {
    where: EducationScalarWhereInput
    data: XOR<EducationUpdateManyMutationInput, EducationUncheckedUpdateManyWithoutUserInput>
  }

  export type EducationScalarWhereInput = {
    AND?: EducationScalarWhereInput | EducationScalarWhereInput[]
    OR?: EducationScalarWhereInput[]
    NOT?: EducationScalarWhereInput | EducationScalarWhereInput[]
    id?: IntFilter<"Education"> | number
    institutionName?: StringFilter<"Education"> | string
    diplomaTitle?: StringFilter<"Education"> | string
    fieldOfStudy?: StringFilter<"Education"> | string
    isCurrent?: BoolFilter<"Education"> | boolean
    duration?: StringFilter<"Education"> | string
    userId?: StringFilter<"Education"> | string
    startDate?: DateTimeNullableFilter<"Education"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Education"> | Date | string | null
  }

  export type ExperienceUpsertWithWhereUniqueWithoutUserInput = {
    where: ExperienceWhereUniqueInput
    update: XOR<ExperienceUpdateWithoutUserInput, ExperienceUncheckedUpdateWithoutUserInput>
    create: XOR<ExperienceCreateWithoutUserInput, ExperienceUncheckedCreateWithoutUserInput>
  }

  export type ExperienceUpdateWithWhereUniqueWithoutUserInput = {
    where: ExperienceWhereUniqueInput
    data: XOR<ExperienceUpdateWithoutUserInput, ExperienceUncheckedUpdateWithoutUserInput>
  }

  export type ExperienceUpdateManyWithWhereWithoutUserInput = {
    where: ExperienceScalarWhereInput
    data: XOR<ExperienceUpdateManyMutationInput, ExperienceUncheckedUpdateManyWithoutUserInput>
  }

  export type ExperienceScalarWhereInput = {
    AND?: ExperienceScalarWhereInput | ExperienceScalarWhereInput[]
    OR?: ExperienceScalarWhereInput[]
    NOT?: ExperienceScalarWhereInput | ExperienceScalarWhereInput[]
    id?: IntFilter<"Experience"> | number
    companyName?: StringFilter<"Experience"> | string
    role?: StringFilter<"Experience"> | string
    isCurrent?: BoolFilter<"Experience"> | boolean
    duration?: StringFilter<"Experience"> | string
    description?: StringFilter<"Experience"> | string
    userId?: StringFilter<"Experience"> | string
    endDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
    startDate?: DateTimeNullableFilter<"Experience"> | Date | string | null
  }

  export type ExpertUpsertWithoutUserInput = {
    update: XOR<ExpertUpdateWithoutUserInput, ExpertUncheckedUpdateWithoutUserInput>
    create: XOR<ExpertCreateWithoutUserInput, ExpertUncheckedCreateWithoutUserInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutUserInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutUserInput, ExpertUncheckedUpdateWithoutUserInput>
  }

  export type ExpertUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type ExpertReviewUpsertWithWhereUniqueWithoutClientInput = {
    where: ExpertReviewWhereUniqueInput
    update: XOR<ExpertReviewUpdateWithoutClientInput, ExpertReviewUncheckedUpdateWithoutClientInput>
    create: XOR<ExpertReviewCreateWithoutClientInput, ExpertReviewUncheckedCreateWithoutClientInput>
  }

  export type ExpertReviewUpdateWithWhereUniqueWithoutClientInput = {
    where: ExpertReviewWhereUniqueInput
    data: XOR<ExpertReviewUpdateWithoutClientInput, ExpertReviewUncheckedUpdateWithoutClientInput>
  }

  export type ExpertReviewUpdateManyWithWhereWithoutClientInput = {
    where: ExpertReviewScalarWhereInput
    data: XOR<ExpertReviewUpdateManyMutationInput, ExpertReviewUncheckedUpdateManyWithoutClientInput>
  }

  export type ExpertReviewScalarWhereInput = {
    AND?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
    OR?: ExpertReviewScalarWhereInput[]
    NOT?: ExpertReviewScalarWhereInput | ExpertReviewScalarWhereInput[]
    id?: IntFilter<"ExpertReview"> | number
    reviewText?: StringNullableFilter<"ExpertReview"> | string | null
    createdAt?: DateTimeFilter<"ExpertReview"> | Date | string
    videoRoomId?: StringFilter<"ExpertReview"> | string
    expertId?: StringFilter<"ExpertReview"> | string
    appointmentKey?: StringFilter<"ExpertReview"> | string
    isDisplayed?: BoolFilter<"ExpertReview"> | boolean
    clientId?: StringFilter<"ExpertReview"> | string
  }

  export type ExpertiseUpsertWithWhereUniqueWithoutUserInput = {
    where: ExpertiseWhereUniqueInput
    update: XOR<ExpertiseUpdateWithoutUserInput, ExpertiseUncheckedUpdateWithoutUserInput>
    create: XOR<ExpertiseCreateWithoutUserInput, ExpertiseUncheckedCreateWithoutUserInput>
  }

  export type ExpertiseUpdateWithWhereUniqueWithoutUserInput = {
    where: ExpertiseWhereUniqueInput
    data: XOR<ExpertiseUpdateWithoutUserInput, ExpertiseUncheckedUpdateWithoutUserInput>
  }

  export type ExpertiseUpdateManyWithWhereWithoutUserInput = {
    where: ExpertiseScalarWhereInput
    data: XOR<ExpertiseUpdateManyMutationInput, ExpertiseUncheckedUpdateManyWithoutUserInput>
  }

  export type ExpertiseScalarWhereInput = {
    AND?: ExpertiseScalarWhereInput | ExpertiseScalarWhereInput[]
    OR?: ExpertiseScalarWhereInput[]
    NOT?: ExpertiseScalarWhereInput | ExpertiseScalarWhereInput[]
    id?: IntFilter<"Expertise"> | number
    field?: StringFilter<"Expertise"> | string
    isCurrent?: BoolFilter<"Expertise"> | boolean
    description?: StringFilter<"Expertise"> | string
    duration?: StringFilter<"Expertise"> | string
    userId?: StringFilter<"Expertise"> | string
    startDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
    endDate?: DateTimeNullableFilter<"Expertise"> | Date | string | null
  }

  export type KeyUpsertWithWhereUniqueWithoutUserInput = {
    where: KeyWhereUniqueInput
    update: XOR<KeyUpdateWithoutUserInput, KeyUncheckedUpdateWithoutUserInput>
    create: XOR<KeyCreateWithoutUserInput, KeyUncheckedCreateWithoutUserInput>
  }

  export type KeyUpdateWithWhereUniqueWithoutUserInput = {
    where: KeyWhereUniqueInput
    data: XOR<KeyUpdateWithoutUserInput, KeyUncheckedUpdateWithoutUserInput>
  }

  export type KeyUpdateManyWithWhereWithoutUserInput = {
    where: KeyScalarWhereInput
    data: XOR<KeyUpdateManyMutationInput, KeyUncheckedUpdateManyWithoutUserInput>
  }

  export type KeyScalarWhereInput = {
    AND?: KeyScalarWhereInput | KeyScalarWhereInput[]
    OR?: KeyScalarWhereInput[]
    NOT?: KeyScalarWhereInput | KeyScalarWhereInput[]
    id?: StringFilter<"Key"> | string
    hashed_password?: StringNullableFilter<"Key"> | string | null
    user_id?: StringFilter<"Key"> | string
  }

  export type LanguageUpsertWithWhereUniqueWithoutUserInput = {
    where: LanguageWhereUniqueInput
    update: XOR<LanguageUpdateWithoutUserInput, LanguageUncheckedUpdateWithoutUserInput>
    create: XOR<LanguageCreateWithoutUserInput, LanguageUncheckedCreateWithoutUserInput>
  }

  export type LanguageUpdateWithWhereUniqueWithoutUserInput = {
    where: LanguageWhereUniqueInput
    data: XOR<LanguageUpdateWithoutUserInput, LanguageUncheckedUpdateWithoutUserInput>
  }

  export type LanguageUpdateManyWithWhereWithoutUserInput = {
    where: LanguageScalarWhereInput
    data: XOR<LanguageUpdateManyMutationInput, LanguageUncheckedUpdateManyWithoutUserInput>
  }

  export type LanguageScalarWhereInput = {
    AND?: LanguageScalarWhereInput | LanguageScalarWhereInput[]
    OR?: LanguageScalarWhereInput[]
    NOT?: LanguageScalarWhereInput | LanguageScalarWhereInput[]
    id?: IntFilter<"Language"> | number
    name?: StringFilter<"Language"> | string
    userId?: StringFilter<"Language"> | string
  }

  export type QuestionUpsertWithWhereUniqueWithoutUserInput = {
    where: QuestionWhereUniqueInput
    update: XOR<QuestionUpdateWithoutUserInput, QuestionUncheckedUpdateWithoutUserInput>
    create: XOR<QuestionCreateWithoutUserInput, QuestionUncheckedCreateWithoutUserInput>
  }

  export type QuestionUpdateWithWhereUniqueWithoutUserInput = {
    where: QuestionWhereUniqueInput
    data: XOR<QuestionUpdateWithoutUserInput, QuestionUncheckedUpdateWithoutUserInput>
  }

  export type QuestionUpdateManyWithWhereWithoutUserInput = {
    where: QuestionScalarWhereInput
    data: XOR<QuestionUpdateManyMutationInput, QuestionUncheckedUpdateManyWithoutUserInput>
  }

  export type QuestionScalarWhereInput = {
    AND?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
    OR?: QuestionScalarWhereInput[]
    NOT?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
    id?: IntFilter<"Question"> | number
    content?: StringFilter<"Question"> | string
    userId?: StringFilter<"Question"> | string
  }

  export type ReplyUpsertWithWhereUniqueWithoutUserInput = {
    where: ReplyWhereUniqueInput
    update: XOR<ReplyUpdateWithoutUserInput, ReplyUncheckedUpdateWithoutUserInput>
    create: XOR<ReplyCreateWithoutUserInput, ReplyUncheckedCreateWithoutUserInput>
  }

  export type ReplyUpdateWithWhereUniqueWithoutUserInput = {
    where: ReplyWhereUniqueInput
    data: XOR<ReplyUpdateWithoutUserInput, ReplyUncheckedUpdateWithoutUserInput>
  }

  export type ReplyUpdateManyWithWhereWithoutUserInput = {
    where: ReplyScalarWhereInput
    data: XOR<ReplyUpdateManyMutationInput, ReplyUncheckedUpdateManyWithoutUserInput>
  }

  export type ReplyScalarWhereInput = {
    AND?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
    OR?: ReplyScalarWhereInput[]
    NOT?: ReplyScalarWhereInput | ReplyScalarWhereInput[]
    id?: IntFilter<"Reply"> | number
    content?: StringFilter<"Reply"> | string
    appointmentKey?: StringFilter<"Reply"> | string
    questionContent?: StringFilter<"Reply"> | string
    userId?: StringFilter<"Reply"> | string
  }

  export type admin_expert_applicationUpsertWithWhereUniqueWithoutUserInput = {
    where: admin_expert_applicationWhereUniqueInput
    update: XOR<admin_expert_applicationUpdateWithoutUserInput, admin_expert_applicationUncheckedUpdateWithoutUserInput>
    create: XOR<admin_expert_applicationCreateWithoutUserInput, admin_expert_applicationUncheckedCreateWithoutUserInput>
  }

  export type admin_expert_applicationUpdateWithWhereUniqueWithoutUserInput = {
    where: admin_expert_applicationWhereUniqueInput
    data: XOR<admin_expert_applicationUpdateWithoutUserInput, admin_expert_applicationUncheckedUpdateWithoutUserInput>
  }

  export type admin_expert_applicationUpdateManyWithWhereWithoutUserInput = {
    where: admin_expert_applicationScalarWhereInput
    data: XOR<admin_expert_applicationUpdateManyMutationInput, admin_expert_applicationUncheckedUpdateManyWithoutUserInput>
  }

  export type admin_expert_applicationScalarWhereInput = {
    AND?: admin_expert_applicationScalarWhereInput | admin_expert_applicationScalarWhereInput[]
    OR?: admin_expert_applicationScalarWhereInput[]
    NOT?: admin_expert_applicationScalarWhereInput | admin_expert_applicationScalarWhereInput[]
    id?: StringFilter<"admin_expert_application"> | string
    status?: EnumStatusFilter<"admin_expert_application"> | $Enums.Status
    createdAt?: DateTimeFilter<"admin_expert_application"> | Date | string
    userId?: StringFilter<"admin_expert_application"> | string
  }

  export type admin_userUpsertWithoutUserInput = {
    update: XOR<admin_userUpdateWithoutUserInput, admin_userUncheckedUpdateWithoutUserInput>
    create: XOR<admin_userCreateWithoutUserInput, admin_userUncheckedCreateWithoutUserInput>
    where?: admin_userWhereInput
  }

  export type admin_userUpdateToOneWithWhereWithoutUserInput = {
    where?: admin_userWhereInput
    data: XOR<admin_userUpdateWithoutUserInput, admin_userUncheckedUpdateWithoutUserInput>
  }

  export type admin_userUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
  }

  export type admin_userUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: NullableEnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole | null
  }

  export type email_verification_tokenUpsertWithWhereUniqueWithoutUserInput = {
    where: email_verification_tokenWhereUniqueInput
    update: XOR<email_verification_tokenUpdateWithoutUserInput, email_verification_tokenUncheckedUpdateWithoutUserInput>
    create: XOR<email_verification_tokenCreateWithoutUserInput, email_verification_tokenUncheckedCreateWithoutUserInput>
  }

  export type email_verification_tokenUpdateWithWhereUniqueWithoutUserInput = {
    where: email_verification_tokenWhereUniqueInput
    data: XOR<email_verification_tokenUpdateWithoutUserInput, email_verification_tokenUncheckedUpdateWithoutUserInput>
  }

  export type email_verification_tokenUpdateManyWithWhereWithoutUserInput = {
    where: email_verification_tokenScalarWhereInput
    data: XOR<email_verification_tokenUpdateManyMutationInput, email_verification_tokenUncheckedUpdateManyWithoutUserInput>
  }

  export type email_verification_tokenScalarWhereInput = {
    AND?: email_verification_tokenScalarWhereInput | email_verification_tokenScalarWhereInput[]
    OR?: email_verification_tokenScalarWhereInput[]
    NOT?: email_verification_tokenScalarWhereInput | email_verification_tokenScalarWhereInput[]
    id?: StringFilter<"email_verification_token"> | string
    expires?: BigIntFilter<"email_verification_token"> | bigint | number
    userId?: StringFilter<"email_verification_token"> | string
  }

  export type expertApplicationAnswerUpsertWithWhereUniqueWithoutUserInput = {
    where: expertApplicationAnswerWhereUniqueInput
    update: XOR<expertApplicationAnswerUpdateWithoutUserInput, expertApplicationAnswerUncheckedUpdateWithoutUserInput>
    create: XOR<expertApplicationAnswerCreateWithoutUserInput, expertApplicationAnswerUncheckedCreateWithoutUserInput>
  }

  export type expertApplicationAnswerUpdateWithWhereUniqueWithoutUserInput = {
    where: expertApplicationAnswerWhereUniqueInput
    data: XOR<expertApplicationAnswerUpdateWithoutUserInput, expertApplicationAnswerUncheckedUpdateWithoutUserInput>
  }

  export type expertApplicationAnswerUpdateManyWithWhereWithoutUserInput = {
    where: expertApplicationAnswerScalarWhereInput
    data: XOR<expertApplicationAnswerUpdateManyMutationInput, expertApplicationAnswerUncheckedUpdateManyWithoutUserInput>
  }

  export type expertApplicationAnswerScalarWhereInput = {
    AND?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
    OR?: expertApplicationAnswerScalarWhereInput[]
    NOT?: expertApplicationAnswerScalarWhereInput | expertApplicationAnswerScalarWhereInput[]
    id?: StringFilter<"expertApplicationAnswer"> | string
    answer?: StringFilter<"expertApplicationAnswer"> | string
    created_at?: DateTimeFilter<"expertApplicationAnswer"> | Date | string
    userId?: StringFilter<"expertApplicationAnswer"> | string
    questionId?: StringFilter<"expertApplicationAnswer"> | string
    admin_expert_applicationId?: StringNullableFilter<"expertApplicationAnswer"> | string | null
  }

  export type id_verificationUpsertWithWhereUniqueWithoutUserInput = {
    where: id_verificationWhereUniqueInput
    update: XOR<id_verificationUpdateWithoutUserInput, id_verificationUncheckedUpdateWithoutUserInput>
    create: XOR<id_verificationCreateWithoutUserInput, id_verificationUncheckedCreateWithoutUserInput>
  }

  export type id_verificationUpdateWithWhereUniqueWithoutUserInput = {
    where: id_verificationWhereUniqueInput
    data: XOR<id_verificationUpdateWithoutUserInput, id_verificationUncheckedUpdateWithoutUserInput>
  }

  export type id_verificationUpdateManyWithWhereWithoutUserInput = {
    where: id_verificationScalarWhereInput
    data: XOR<id_verificationUpdateManyMutationInput, id_verificationUncheckedUpdateManyWithoutUserInput>
  }

  export type id_verificationScalarWhereInput = {
    AND?: id_verificationScalarWhereInput | id_verificationScalarWhereInput[]
    OR?: id_verificationScalarWhereInput[]
    NOT?: id_verificationScalarWhereInput | id_verificationScalarWhereInput[]
    id?: IntFilter<"id_verification"> | number
    status?: EnumStatusFilter<"id_verification"> | $Enums.Status
    userId?: StringFilter<"id_verification"> | string
    idImageUrlBack?: StringNullableFilter<"id_verification"> | string | null
    idImageUrlFront?: StringFilter<"id_verification"> | string
    createdAt?: DateTimeFilter<"id_verification"> | Date | string
    documentType?: EnumdocumentTypeFilter<"id_verification"> | $Enums.documentType
  }

  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
    user_id?: StringFilter<"session"> | string
    active_expires?: BigIntFilter<"session"> | bigint | number
    idle_expires?: BigIntFilter<"session"> | bigint | number
  }

  export type AppointmentCreateWithoutExpertInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    client: UserCreateNestedOneWithoutAppointmentInput
    receivedClientReviews?: ClientReviewCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewCreateNestedOneWithoutAppointmentInput
    reply?: ReplyCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutExpertInput = {
    id?: number
    clientId: string
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    receivedClientReviews?: ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput
    reply?: ReplyUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutExpertInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput>
  }

  export type AppointmentCreateManyExpertInputEnvelope = {
    data: AppointmentCreateManyExpertInput | AppointmentCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type AvailabilityCreateWithoutExpertInput = {
    day: string
    timezone: string
    user?: UserCreateNestedOneWithoutAvailabilitiesInput
    slots?: SlotCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityUncheckedCreateWithoutExpertInput = {
    id?: number
    day: string
    timezone: string
    userId?: string | null
    slots?: SlotUncheckedCreateNestedManyWithoutAvailabilityInput
  }

  export type AvailabilityCreateOrConnectWithoutExpertInput = {
    where: AvailabilityWhereUniqueInput
    create: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput>
  }

  export type AvailabilityCreateManyExpertInputEnvelope = {
    data: AvailabilityCreateManyExpertInput | AvailabilityCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type ChatCreateWithoutExpertInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    client: UserCreateNestedOneWithoutChatInput
    messages?: ChatMessageCreateNestedManyWithoutChatInput
  }

  export type ChatUncheckedCreateWithoutExpertInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    clientId: string
    messages?: ChatMessageUncheckedCreateNestedManyWithoutChatInput
  }

  export type ChatCreateOrConnectWithoutExpertInput = {
    where: ChatWhereUniqueInput
    create: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput>
  }

  export type ChatCreateManyExpertInputEnvelope = {
    data: ChatCreateManyExpertInput | ChatCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type ChatMessageCreateWithoutExpertInput = {
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chat: ChatCreateNestedOneWithoutMessagesInput
    sender: UserCreateNestedOneWithoutMessagesInput
  }

  export type ChatMessageUncheckedCreateWithoutExpertInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    senderId: string
  }

  export type ChatMessageCreateOrConnectWithoutExpertInput = {
    where: ChatMessageWhereUniqueInput
    create: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput>
  }

  export type ChatMessageCreateManyExpertInputEnvelope = {
    data: ChatMessageCreateManyExpertInput | ChatMessageCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type ClientReviewCreateWithoutExpertInput = {
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutReceivedClientReviewsInput
    client: UserCreateNestedOneWithoutReceivedClientReviewsInput
  }

  export type ClientReviewUncheckedCreateWithoutExpertInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ClientReviewCreateOrConnectWithoutExpertInput = {
    where: ClientReviewWhereUniqueInput
    create: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput>
  }

  export type ClientReviewCreateManyExpertInputEnvelope = {
    data: ClientReviewCreateManyExpertInput | ClientReviewCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutExpertInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutExpertInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutExpertInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutExpertInput, UserUncheckedCreateWithoutExpertInput>
  }

  export type ExpertReviewCreateWithoutExpertInput = {
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    appointment: AppointmentCreateNestedOneWithoutWrittenExpertReviewsInput
    client: UserCreateNestedOneWithoutWrittenExpertReviewsInput
  }

  export type ExpertReviewUncheckedCreateWithoutExpertInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ExpertReviewCreateOrConnectWithoutExpertInput = {
    where: ExpertReviewWhereUniqueInput
    create: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput>
  }

  export type ExpertReviewCreateManyExpertInputEnvelope = {
    data: ExpertReviewCreateManyExpertInput | ExpertReviewCreateManyExpertInput[]
    skipDuplicates?: boolean
  }

  export type StripeAccountCreateWithoutExpertInput = {
    stripeData: JsonNullValueInput | InputJsonValue
  }

  export type StripeAccountUncheckedCreateWithoutExpertInput = {
    id?: number
    stripeData: JsonNullValueInput | InputJsonValue
  }

  export type StripeAccountCreateOrConnectWithoutExpertInput = {
    where: StripeAccountWhereUniqueInput
    create: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
  }

  export type AppointmentUpsertWithWhereUniqueWithoutExpertInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutExpertInput, AppointmentUncheckedUpdateWithoutExpertInput>
    create: XOR<AppointmentCreateWithoutExpertInput, AppointmentUncheckedCreateWithoutExpertInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutExpertInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutExpertInput, AppointmentUncheckedUpdateWithoutExpertInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutExpertInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutExpertInput>
  }

  export type AvailabilityUpsertWithWhereUniqueWithoutExpertInput = {
    where: AvailabilityWhereUniqueInput
    update: XOR<AvailabilityUpdateWithoutExpertInput, AvailabilityUncheckedUpdateWithoutExpertInput>
    create: XOR<AvailabilityCreateWithoutExpertInput, AvailabilityUncheckedCreateWithoutExpertInput>
  }

  export type AvailabilityUpdateWithWhereUniqueWithoutExpertInput = {
    where: AvailabilityWhereUniqueInput
    data: XOR<AvailabilityUpdateWithoutExpertInput, AvailabilityUncheckedUpdateWithoutExpertInput>
  }

  export type AvailabilityUpdateManyWithWhereWithoutExpertInput = {
    where: AvailabilityScalarWhereInput
    data: XOR<AvailabilityUpdateManyMutationInput, AvailabilityUncheckedUpdateManyWithoutExpertInput>
  }

  export type ChatUpsertWithWhereUniqueWithoutExpertInput = {
    where: ChatWhereUniqueInput
    update: XOR<ChatUpdateWithoutExpertInput, ChatUncheckedUpdateWithoutExpertInput>
    create: XOR<ChatCreateWithoutExpertInput, ChatUncheckedCreateWithoutExpertInput>
  }

  export type ChatUpdateWithWhereUniqueWithoutExpertInput = {
    where: ChatWhereUniqueInput
    data: XOR<ChatUpdateWithoutExpertInput, ChatUncheckedUpdateWithoutExpertInput>
  }

  export type ChatUpdateManyWithWhereWithoutExpertInput = {
    where: ChatScalarWhereInput
    data: XOR<ChatUpdateManyMutationInput, ChatUncheckedUpdateManyWithoutExpertInput>
  }

  export type ChatMessageUpsertWithWhereUniqueWithoutExpertInput = {
    where: ChatMessageWhereUniqueInput
    update: XOR<ChatMessageUpdateWithoutExpertInput, ChatMessageUncheckedUpdateWithoutExpertInput>
    create: XOR<ChatMessageCreateWithoutExpertInput, ChatMessageUncheckedCreateWithoutExpertInput>
  }

  export type ChatMessageUpdateWithWhereUniqueWithoutExpertInput = {
    where: ChatMessageWhereUniqueInput
    data: XOR<ChatMessageUpdateWithoutExpertInput, ChatMessageUncheckedUpdateWithoutExpertInput>
  }

  export type ChatMessageUpdateManyWithWhereWithoutExpertInput = {
    where: ChatMessageScalarWhereInput
    data: XOR<ChatMessageUpdateManyMutationInput, ChatMessageUncheckedUpdateManyWithoutExpertInput>
  }

  export type ClientReviewUpsertWithWhereUniqueWithoutExpertInput = {
    where: ClientReviewWhereUniqueInput
    update: XOR<ClientReviewUpdateWithoutExpertInput, ClientReviewUncheckedUpdateWithoutExpertInput>
    create: XOR<ClientReviewCreateWithoutExpertInput, ClientReviewUncheckedCreateWithoutExpertInput>
  }

  export type ClientReviewUpdateWithWhereUniqueWithoutExpertInput = {
    where: ClientReviewWhereUniqueInput
    data: XOR<ClientReviewUpdateWithoutExpertInput, ClientReviewUncheckedUpdateWithoutExpertInput>
  }

  export type ClientReviewUpdateManyWithWhereWithoutExpertInput = {
    where: ClientReviewScalarWhereInput
    data: XOR<ClientReviewUpdateManyMutationInput, ClientReviewUncheckedUpdateManyWithoutExpertInput>
  }

  export type UserUpsertWithoutExpertInput = {
    update: XOR<UserUpdateWithoutExpertInput, UserUncheckedUpdateWithoutExpertInput>
    create: XOR<UserCreateWithoutExpertInput, UserUncheckedCreateWithoutExpertInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutExpertInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutExpertInput, UserUncheckedUpdateWithoutExpertInput>
  }

  export type UserUpdateWithoutExpertInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutExpertInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertReviewUpsertWithWhereUniqueWithoutExpertInput = {
    where: ExpertReviewWhereUniqueInput
    update: XOR<ExpertReviewUpdateWithoutExpertInput, ExpertReviewUncheckedUpdateWithoutExpertInput>
    create: XOR<ExpertReviewCreateWithoutExpertInput, ExpertReviewUncheckedCreateWithoutExpertInput>
  }

  export type ExpertReviewUpdateWithWhereUniqueWithoutExpertInput = {
    where: ExpertReviewWhereUniqueInput
    data: XOR<ExpertReviewUpdateWithoutExpertInput, ExpertReviewUncheckedUpdateWithoutExpertInput>
  }

  export type ExpertReviewUpdateManyWithWhereWithoutExpertInput = {
    where: ExpertReviewScalarWhereInput
    data: XOR<ExpertReviewUpdateManyMutationInput, ExpertReviewUncheckedUpdateManyWithoutExpertInput>
  }

  export type StripeAccountUpsertWithoutExpertInput = {
    update: XOR<StripeAccountUpdateWithoutExpertInput, StripeAccountUncheckedUpdateWithoutExpertInput>
    create: XOR<StripeAccountCreateWithoutExpertInput, StripeAccountUncheckedCreateWithoutExpertInput>
    where?: StripeAccountWhereInput
  }

  export type StripeAccountUpdateToOneWithWhereWithoutExpertInput = {
    where?: StripeAccountWhereInput
    data: XOR<StripeAccountUpdateWithoutExpertInput, StripeAccountUncheckedUpdateWithoutExpertInput>
  }

  export type StripeAccountUpdateWithoutExpertInput = {
    stripeData?: JsonNullValueInput | InputJsonValue
  }

  export type StripeAccountUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    stripeData?: JsonNullValueInput | InputJsonValue
  }

  export type UserCreateWithoutId_verificationInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutId_verificationInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutId_verificationInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutId_verificationInput, UserUncheckedCreateWithoutId_verificationInput>
  }

  export type UserUpsertWithoutId_verificationInput = {
    update: XOR<UserUpdateWithoutId_verificationInput, UserUncheckedUpdateWithoutId_verificationInput>
    create: XOR<UserCreateWithoutId_verificationInput, UserUncheckedCreateWithoutId_verificationInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutId_verificationInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutId_verificationInput, UserUncheckedUpdateWithoutId_verificationInput>
  }

  export type UserUpdateWithoutId_verificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutId_verificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutEmail_verification_tokenInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutEmail_verification_tokenInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutEmail_verification_tokenInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEmail_verification_tokenInput, UserUncheckedCreateWithoutEmail_verification_tokenInput>
  }

  export type UserUpsertWithoutEmail_verification_tokenInput = {
    update: XOR<UserUpdateWithoutEmail_verification_tokenInput, UserUncheckedUpdateWithoutEmail_verification_tokenInput>
    create: XOR<UserCreateWithoutEmail_verification_tokenInput, UserUncheckedCreateWithoutEmail_verification_tokenInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEmail_verification_tokenInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEmail_verification_tokenInput, UserUncheckedUpdateWithoutEmail_verification_tokenInput>
  }

  export type UserUpdateWithoutEmail_verification_tokenInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutEmail_verification_tokenInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutQuestionsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutQuestionsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutQuestionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutQuestionsInput, UserUncheckedCreateWithoutQuestionsInput>
  }

  export type UserUpsertWithoutQuestionsInput = {
    update: XOR<UserUpdateWithoutQuestionsInput, UserUncheckedUpdateWithoutQuestionsInput>
    create: XOR<UserCreateWithoutQuestionsInput, UserUncheckedCreateWithoutQuestionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutQuestionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutQuestionsInput, UserUncheckedUpdateWithoutQuestionsInput>
  }

  export type UserUpdateWithoutQuestionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutQuestionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentCreateWithoutReplyInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    client: UserCreateNestedOneWithoutAppointmentInput
    expert: ExpertCreateNestedOneWithoutAppointmentInput
    receivedClientReviews?: ClientReviewCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutReplyInput = {
    id?: number
    clientId: string
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    receivedClientReviews?: ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutReplyInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutReplyInput, AppointmentUncheckedCreateWithoutReplyInput>
  }

  export type UserCreateWithoutReplyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutReplyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutReplyInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutReplyInput, UserUncheckedCreateWithoutReplyInput>
  }

  export type AppointmentUpsertWithoutReplyInput = {
    update: XOR<AppointmentUpdateWithoutReplyInput, AppointmentUncheckedUpdateWithoutReplyInput>
    create: XOR<AppointmentCreateWithoutReplyInput, AppointmentUncheckedCreateWithoutReplyInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutReplyInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutReplyInput, AppointmentUncheckedUpdateWithoutReplyInput>
  }

  export type AppointmentUpdateWithoutReplyInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    client?: UserUpdateOneRequiredWithoutAppointmentNestedInput
    expert?: ExpertUpdateOneRequiredWithoutAppointmentNestedInput
    receivedClientReviews?: ClientReviewUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUpdateOneWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutReplyInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    receivedClientReviews?: ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput
  }

  export type UserUpsertWithoutReplyInput = {
    update: XOR<UserUpdateWithoutReplyInput, UserUncheckedUpdateWithoutReplyInput>
    create: XOR<UserCreateWithoutReplyInput, UserUncheckedCreateWithoutReplyInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutReplyInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutReplyInput, UserUncheckedUpdateWithoutReplyInput>
  }

  export type UserUpdateWithoutReplyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutReplyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertCreateWithoutStripeAccountInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutStripeAccountInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutStripeAccountInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutStripeAccountInput, ExpertUncheckedCreateWithoutStripeAccountInput>
  }

  export type ExpertUpsertWithoutStripeAccountInput = {
    update: XOR<ExpertUpdateWithoutStripeAccountInput, ExpertUncheckedUpdateWithoutStripeAccountInput>
    create: XOR<ExpertCreateWithoutStripeAccountInput, ExpertUncheckedCreateWithoutStripeAccountInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutStripeAccountInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutStripeAccountInput, ExpertUncheckedUpdateWithoutStripeAccountInput>
  }

  export type ExpertUpdateWithoutStripeAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutStripeAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
  }

  export type UserCreateWithoutKeyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutKeyInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutKeyInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutKeyInput, UserUncheckedCreateWithoutKeyInput>
  }

  export type UserUpsertWithoutKeyInput = {
    update: XOR<UserUpdateWithoutKeyInput, UserUncheckedUpdateWithoutKeyInput>
    create: XOR<UserCreateWithoutKeyInput, UserUncheckedCreateWithoutKeyInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutKeyInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutKeyInput, UserUncheckedUpdateWithoutKeyInput>
  }

  export type UserUpdateWithoutKeyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutKeyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutExperiencesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutExperiencesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutExperiencesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutExperiencesInput, UserUncheckedCreateWithoutExperiencesInput>
  }

  export type UserUpsertWithoutExperiencesInput = {
    update: XOR<UserUpdateWithoutExperiencesInput, UserUncheckedUpdateWithoutExperiencesInput>
    create: XOR<UserCreateWithoutExperiencesInput, UserUncheckedCreateWithoutExperiencesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutExperiencesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutExperiencesInput, UserUncheckedUpdateWithoutExperiencesInput>
  }

  export type UserUpdateWithoutExperiencesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutExperiencesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutEducationsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutEducationsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutEducationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEducationsInput, UserUncheckedCreateWithoutEducationsInput>
  }

  export type UserUpsertWithoutEducationsInput = {
    update: XOR<UserUpdateWithoutEducationsInput, UserUncheckedUpdateWithoutEducationsInput>
    create: XOR<UserCreateWithoutEducationsInput, UserUncheckedCreateWithoutEducationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEducationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEducationsInput, UserUncheckedUpdateWithoutEducationsInput>
  }

  export type UserUpdateWithoutEducationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutEducationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutExpertisesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutExpertisesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutExpertisesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutExpertisesInput, UserUncheckedCreateWithoutExpertisesInput>
  }

  export type UserUpsertWithoutExpertisesInput = {
    update: XOR<UserUpdateWithoutExpertisesInput, UserUncheckedUpdateWithoutExpertisesInput>
    create: XOR<UserCreateWithoutExpertisesInput, UserUncheckedCreateWithoutExpertisesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutExpertisesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutExpertisesInput, UserUncheckedUpdateWithoutExpertisesInput>
  }

  export type UserUpdateWithoutExpertisesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutExpertisesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutLanguagesSpokenInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutLanguagesSpokenInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutLanguagesSpokenInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutLanguagesSpokenInput, UserUncheckedCreateWithoutLanguagesSpokenInput>
  }

  export type UserUpsertWithoutLanguagesSpokenInput = {
    update: XOR<UserUpdateWithoutLanguagesSpokenInput, UserUncheckedUpdateWithoutLanguagesSpokenInput>
    create: XOR<UserCreateWithoutLanguagesSpokenInput, UserUncheckedCreateWithoutLanguagesSpokenInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutLanguagesSpokenInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutLanguagesSpokenInput, UserUncheckedUpdateWithoutLanguagesSpokenInput>
  }

  export type UserUpdateWithoutLanguagesSpokenInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutLanguagesSpokenInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutAppointmentInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAppointmentInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAppointmentInput, UserUncheckedCreateWithoutAppointmentInput>
  }

  export type ExpertCreateWithoutAppointmentInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutAppointmentInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutAppointmentInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutAppointmentInput, ExpertUncheckedCreateWithoutAppointmentInput>
  }

  export type ClientReviewCreateWithoutAppointmentInput = {
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    client: UserCreateNestedOneWithoutReceivedClientReviewsInput
    expert: ExpertCreateNestedOneWithoutClientReviewInput
  }

  export type ClientReviewUncheckedCreateWithoutAppointmentInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    clientId: string
    expertId: string
  }

  export type ClientReviewCreateOrConnectWithoutAppointmentInput = {
    where: ClientReviewWhereUniqueInput
    create: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
  }

  export type ExpertReviewCreateWithoutAppointmentInput = {
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    isDisplayed?: boolean
    client: UserCreateNestedOneWithoutWrittenExpertReviewsInput
    expert: ExpertCreateNestedOneWithoutExpertReviewInput
  }

  export type ExpertReviewUncheckedCreateWithoutAppointmentInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    expertId: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ExpertReviewCreateOrConnectWithoutAppointmentInput = {
    where: ExpertReviewWhereUniqueInput
    create: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
  }

  export type ReplyCreateWithoutAppointmentInput = {
    content: string
    questionContent: string
    user: UserCreateNestedOneWithoutReplyInput
  }

  export type ReplyUncheckedCreateWithoutAppointmentInput = {
    id?: number
    content: string
    questionContent: string
    userId: string
  }

  export type ReplyCreateOrConnectWithoutAppointmentInput = {
    where: ReplyWhereUniqueInput
    create: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput>
  }

  export type ReplyCreateManyAppointmentInputEnvelope = {
    data: ReplyCreateManyAppointmentInput | ReplyCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutAppointmentInput = {
    update: XOR<UserUpdateWithoutAppointmentInput, UserUncheckedUpdateWithoutAppointmentInput>
    create: XOR<UserCreateWithoutAppointmentInput, UserUncheckedCreateWithoutAppointmentInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAppointmentInput, UserUncheckedUpdateWithoutAppointmentInput>
  }

  export type UserUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertUpsertWithoutAppointmentInput = {
    update: XOR<ExpertUpdateWithoutAppointmentInput, ExpertUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ExpertCreateWithoutAppointmentInput, ExpertUncheckedCreateWithoutAppointmentInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutAppointmentInput, ExpertUncheckedUpdateWithoutAppointmentInput>
  }

  export type ExpertUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type ClientReviewUpsertWithoutAppointmentInput = {
    update: XOR<ClientReviewUpdateWithoutAppointmentInput, ClientReviewUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ClientReviewCreateWithoutAppointmentInput, ClientReviewUncheckedCreateWithoutAppointmentInput>
    where?: ClientReviewWhereInput
  }

  export type ClientReviewUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: ClientReviewWhereInput
    data: XOR<ClientReviewUpdateWithoutAppointmentInput, ClientReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ClientReviewUpdateWithoutAppointmentInput = {
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    client?: UserUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutClientReviewNestedInput
  }

  export type ClientReviewUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertReviewUpsertWithoutAppointmentInput = {
    update: XOR<ExpertReviewUpdateWithoutAppointmentInput, ExpertReviewUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ExpertReviewCreateWithoutAppointmentInput, ExpertReviewUncheckedCreateWithoutAppointmentInput>
    where?: ExpertReviewWhereInput
  }

  export type ExpertReviewUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: ExpertReviewWhereInput
    data: XOR<ExpertReviewUpdateWithoutAppointmentInput, ExpertReviewUncheckedUpdateWithoutAppointmentInput>
  }

  export type ExpertReviewUpdateWithoutAppointmentInput = {
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    client?: UserUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutExpertReviewNestedInput
  }

  export type ExpertReviewUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: ReplyWhereUniqueInput
    update: XOR<ReplyUpdateWithoutAppointmentInput, ReplyUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ReplyCreateWithoutAppointmentInput, ReplyUncheckedCreateWithoutAppointmentInput>
  }

  export type ReplyUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: ReplyWhereUniqueInput
    data: XOR<ReplyUpdateWithoutAppointmentInput, ReplyUncheckedUpdateWithoutAppointmentInput>
  }

  export type ReplyUpdateManyWithWhereWithoutAppointmentInput = {
    where: ReplyScalarWhereInput
    data: XOR<ReplyUpdateManyMutationInput, ReplyUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type ExpertCreateWithoutAvailabilitiesInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutAvailabilitiesInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutAvailabilitiesInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutAvailabilitiesInput, ExpertUncheckedCreateWithoutAvailabilitiesInput>
  }

  export type UserCreateWithoutAvailabilitiesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAvailabilitiesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAvailabilitiesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAvailabilitiesInput, UserUncheckedCreateWithoutAvailabilitiesInput>
  }

  export type SlotCreateWithoutAvailabilityInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId: string
    exceptions?: ExceptionCreateNestedManyWithoutSlotInput
  }

  export type SlotUncheckedCreateWithoutAvailabilityInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId: string
    exceptions?: ExceptionUncheckedCreateNestedManyWithoutSlotInput
  }

  export type SlotCreateOrConnectWithoutAvailabilityInput = {
    where: SlotWhereUniqueInput
    create: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput>
  }

  export type SlotCreateManyAvailabilityInputEnvelope = {
    data: SlotCreateManyAvailabilityInput | SlotCreateManyAvailabilityInput[]
    skipDuplicates?: boolean
  }

  export type ExpertUpsertWithoutAvailabilitiesInput = {
    update: XOR<ExpertUpdateWithoutAvailabilitiesInput, ExpertUncheckedUpdateWithoutAvailabilitiesInput>
    create: XOR<ExpertCreateWithoutAvailabilitiesInput, ExpertUncheckedCreateWithoutAvailabilitiesInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutAvailabilitiesInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutAvailabilitiesInput, ExpertUncheckedUpdateWithoutAvailabilitiesInput>
  }

  export type ExpertUpdateWithoutAvailabilitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutAvailabilitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type UserUpsertWithoutAvailabilitiesInput = {
    update: XOR<UserUpdateWithoutAvailabilitiesInput, UserUncheckedUpdateWithoutAvailabilitiesInput>
    create: XOR<UserCreateWithoutAvailabilitiesInput, UserUncheckedCreateWithoutAvailabilitiesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAvailabilitiesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAvailabilitiesInput, UserUncheckedUpdateWithoutAvailabilitiesInput>
  }

  export type UserUpdateWithoutAvailabilitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAvailabilitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type SlotUpsertWithWhereUniqueWithoutAvailabilityInput = {
    where: SlotWhereUniqueInput
    update: XOR<SlotUpdateWithoutAvailabilityInput, SlotUncheckedUpdateWithoutAvailabilityInput>
    create: XOR<SlotCreateWithoutAvailabilityInput, SlotUncheckedCreateWithoutAvailabilityInput>
  }

  export type SlotUpdateWithWhereUniqueWithoutAvailabilityInput = {
    where: SlotWhereUniqueInput
    data: XOR<SlotUpdateWithoutAvailabilityInput, SlotUncheckedUpdateWithoutAvailabilityInput>
  }

  export type SlotUpdateManyWithWhereWithoutAvailabilityInput = {
    where: SlotScalarWhereInput
    data: XOR<SlotUpdateManyMutationInput, SlotUncheckedUpdateManyWithoutAvailabilityInput>
  }

  export type SlotScalarWhereInput = {
    AND?: SlotScalarWhereInput | SlotScalarWhereInput[]
    OR?: SlotScalarWhereInput[]
    NOT?: SlotScalarWhereInput | SlotScalarWhereInput[]
    id?: StringFilter<"Slot"> | string
    start?: StringFilter<"Slot"> | string
    end?: StringFilter<"Slot"> | string
    recurring?: BoolFilter<"Slot"> | boolean
    availabilityId?: IntFilter<"Slot"> | number
    hide?: BoolFilter<"Slot"> | boolean
    isSplit?: BoolFilter<"Slot"> | boolean
    originalId?: StringFilter<"Slot"> | string
  }

  export type ExceptionCreateWithoutSlotInput = {
    date: string
  }

  export type ExceptionUncheckedCreateWithoutSlotInput = {
    id?: number
    date: string
  }

  export type ExceptionCreateOrConnectWithoutSlotInput = {
    where: ExceptionWhereUniqueInput
    create: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput>
  }

  export type ExceptionCreateManySlotInputEnvelope = {
    data: ExceptionCreateManySlotInput | ExceptionCreateManySlotInput[]
    skipDuplicates?: boolean
  }

  export type AvailabilityCreateWithoutSlotsInput = {
    day: string
    timezone: string
    expert: ExpertCreateNestedOneWithoutAvailabilitiesInput
    user?: UserCreateNestedOneWithoutAvailabilitiesInput
  }

  export type AvailabilityUncheckedCreateWithoutSlotsInput = {
    id?: number
    day: string
    timezone: string
    expertId: string
    userId?: string | null
  }

  export type AvailabilityCreateOrConnectWithoutSlotsInput = {
    where: AvailabilityWhereUniqueInput
    create: XOR<AvailabilityCreateWithoutSlotsInput, AvailabilityUncheckedCreateWithoutSlotsInput>
  }

  export type ExceptionUpsertWithWhereUniqueWithoutSlotInput = {
    where: ExceptionWhereUniqueInput
    update: XOR<ExceptionUpdateWithoutSlotInput, ExceptionUncheckedUpdateWithoutSlotInput>
    create: XOR<ExceptionCreateWithoutSlotInput, ExceptionUncheckedCreateWithoutSlotInput>
  }

  export type ExceptionUpdateWithWhereUniqueWithoutSlotInput = {
    where: ExceptionWhereUniqueInput
    data: XOR<ExceptionUpdateWithoutSlotInput, ExceptionUncheckedUpdateWithoutSlotInput>
  }

  export type ExceptionUpdateManyWithWhereWithoutSlotInput = {
    where: ExceptionScalarWhereInput
    data: XOR<ExceptionUpdateManyMutationInput, ExceptionUncheckedUpdateManyWithoutSlotInput>
  }

  export type ExceptionScalarWhereInput = {
    AND?: ExceptionScalarWhereInput | ExceptionScalarWhereInput[]
    OR?: ExceptionScalarWhereInput[]
    NOT?: ExceptionScalarWhereInput | ExceptionScalarWhereInput[]
    id?: IntFilter<"Exception"> | number
    date?: StringFilter<"Exception"> | string
    slotId?: StringFilter<"Exception"> | string
  }

  export type AvailabilityUpsertWithoutSlotsInput = {
    update: XOR<AvailabilityUpdateWithoutSlotsInput, AvailabilityUncheckedUpdateWithoutSlotsInput>
    create: XOR<AvailabilityCreateWithoutSlotsInput, AvailabilityUncheckedCreateWithoutSlotsInput>
    where?: AvailabilityWhereInput
  }

  export type AvailabilityUpdateToOneWithWhereWithoutSlotsInput = {
    where?: AvailabilityWhereInput
    data: XOR<AvailabilityUpdateWithoutSlotsInput, AvailabilityUncheckedUpdateWithoutSlotsInput>
  }

  export type AvailabilityUpdateWithoutSlotsInput = {
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expert?: ExpertUpdateOneRequiredWithoutAvailabilitiesNestedInput
    user?: UserUpdateOneWithoutAvailabilitiesNestedInput
  }

  export type AvailabilityUncheckedUpdateWithoutSlotsInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SlotCreateWithoutExceptionsInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId: string
    Availability: AvailabilityCreateNestedOneWithoutSlotsInput
  }

  export type SlotUncheckedCreateWithoutExceptionsInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    availabilityId: number
    hide?: boolean
    isSplit?: boolean
    originalId: string
  }

  export type SlotCreateOrConnectWithoutExceptionsInput = {
    where: SlotWhereUniqueInput
    create: XOR<SlotCreateWithoutExceptionsInput, SlotUncheckedCreateWithoutExceptionsInput>
  }

  export type SlotUpsertWithoutExceptionsInput = {
    update: XOR<SlotUpdateWithoutExceptionsInput, SlotUncheckedUpdateWithoutExceptionsInput>
    create: XOR<SlotCreateWithoutExceptionsInput, SlotUncheckedCreateWithoutExceptionsInput>
    where?: SlotWhereInput
  }

  export type SlotUpdateToOneWithWhereWithoutExceptionsInput = {
    where?: SlotWhereInput
    data: XOR<SlotUpdateWithoutExceptionsInput, SlotUncheckedUpdateWithoutExceptionsInput>
  }

  export type SlotUpdateWithoutExceptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
    Availability?: AvailabilityUpdateOneRequiredWithoutSlotsNestedInput
  }

  export type SlotUncheckedUpdateWithoutExceptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    availabilityId?: IntFieldUpdateOperationsInput | number
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
  }

  export type UserCreateWithoutChatInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutChatInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutChatInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutChatInput, UserUncheckedCreateWithoutChatInput>
  }

  export type ExpertCreateWithoutChatInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutChatInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutChatInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutChatInput, ExpertUncheckedCreateWithoutChatInput>
  }

  export type ChatMessageCreateWithoutChatInput = {
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    Expert?: ExpertCreateNestedOneWithoutChatMessageInput
    sender: UserCreateNestedOneWithoutMessagesInput
  }

  export type ChatMessageUncheckedCreateWithoutChatInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    senderId: string
    expertId?: string | null
  }

  export type ChatMessageCreateOrConnectWithoutChatInput = {
    where: ChatMessageWhereUniqueInput
    create: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput>
  }

  export type ChatMessageCreateManyChatInputEnvelope = {
    data: ChatMessageCreateManyChatInput | ChatMessageCreateManyChatInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutChatInput = {
    update: XOR<UserUpdateWithoutChatInput, UserUncheckedUpdateWithoutChatInput>
    create: XOR<UserCreateWithoutChatInput, UserUncheckedCreateWithoutChatInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutChatInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutChatInput, UserUncheckedUpdateWithoutChatInput>
  }

  export type UserUpdateWithoutChatInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutChatInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertUpsertWithoutChatInput = {
    update: XOR<ExpertUpdateWithoutChatInput, ExpertUncheckedUpdateWithoutChatInput>
    create: XOR<ExpertCreateWithoutChatInput, ExpertUncheckedCreateWithoutChatInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutChatInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutChatInput, ExpertUncheckedUpdateWithoutChatInput>
  }

  export type ExpertUpdateWithoutChatInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutChatInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type ChatMessageUpsertWithWhereUniqueWithoutChatInput = {
    where: ChatMessageWhereUniqueInput
    update: XOR<ChatMessageUpdateWithoutChatInput, ChatMessageUncheckedUpdateWithoutChatInput>
    create: XOR<ChatMessageCreateWithoutChatInput, ChatMessageUncheckedCreateWithoutChatInput>
  }

  export type ChatMessageUpdateWithWhereUniqueWithoutChatInput = {
    where: ChatMessageWhereUniqueInput
    data: XOR<ChatMessageUpdateWithoutChatInput, ChatMessageUncheckedUpdateWithoutChatInput>
  }

  export type ChatMessageUpdateManyWithWhereWithoutChatInput = {
    where: ChatMessageScalarWhereInput
    data: XOR<ChatMessageUpdateManyMutationInput, ChatMessageUncheckedUpdateManyWithoutChatInput>
  }

  export type ChatCreateWithoutMessagesInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    client: UserCreateNestedOneWithoutChatInput
    expert: ExpertCreateNestedOneWithoutChatInput
  }

  export type ChatUncheckedCreateWithoutMessagesInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    clientId: string
    expertId: string
  }

  export type ChatCreateOrConnectWithoutMessagesInput = {
    where: ChatWhereUniqueInput
    create: XOR<ChatCreateWithoutMessagesInput, ChatUncheckedCreateWithoutMessagesInput>
  }

  export type ExpertCreateWithoutChatMessageInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutChatMessageInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutChatMessageInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutChatMessageInput, ExpertUncheckedCreateWithoutChatMessageInput>
  }

  export type UserCreateWithoutMessagesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMessagesInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMessagesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMessagesInput, UserUncheckedCreateWithoutMessagesInput>
  }

  export type ChatUpsertWithoutMessagesInput = {
    update: XOR<ChatUpdateWithoutMessagesInput, ChatUncheckedUpdateWithoutMessagesInput>
    create: XOR<ChatCreateWithoutMessagesInput, ChatUncheckedCreateWithoutMessagesInput>
    where?: ChatWhereInput
  }

  export type ChatUpdateToOneWithWhereWithoutMessagesInput = {
    where?: ChatWhereInput
    data: XOR<ChatUpdateWithoutMessagesInput, ChatUncheckedUpdateWithoutMessagesInput>
  }

  export type ChatUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    client?: UserUpdateOneRequiredWithoutChatNestedInput
    expert?: ExpertUpdateOneRequiredWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    clientId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertUpsertWithoutChatMessageInput = {
    update: XOR<ExpertUpdateWithoutChatMessageInput, ExpertUncheckedUpdateWithoutChatMessageInput>
    create: XOR<ExpertCreateWithoutChatMessageInput, ExpertUncheckedCreateWithoutChatMessageInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutChatMessageInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutChatMessageInput, ExpertUncheckedUpdateWithoutChatMessageInput>
  }

  export type ExpertUpdateWithoutChatMessageInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutChatMessageInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type UserUpsertWithoutMessagesInput = {
    update: XOR<UserUpdateWithoutMessagesInput, UserUncheckedUpdateWithoutMessagesInput>
    create: XOR<UserCreateWithoutMessagesInput, UserUncheckedCreateWithoutMessagesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutMessagesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutMessagesInput, UserUncheckedUpdateWithoutMessagesInput>
  }

  export type UserUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentCreateWithoutReceivedClientReviewsInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    client: UserCreateNestedOneWithoutAppointmentInput
    expert: ExpertCreateNestedOneWithoutAppointmentInput
    writtenExpertReviews?: ExpertReviewCreateNestedOneWithoutAppointmentInput
    reply?: ReplyCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutReceivedClientReviewsInput = {
    id?: number
    clientId: string
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedOneWithoutAppointmentInput
    reply?: ReplyUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutReceivedClientReviewsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutReceivedClientReviewsInput, AppointmentUncheckedCreateWithoutReceivedClientReviewsInput>
  }

  export type UserCreateWithoutReceivedClientReviewsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutReceivedClientReviewsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutReceivedClientReviewsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutReceivedClientReviewsInput, UserUncheckedCreateWithoutReceivedClientReviewsInput>
  }

  export type ExpertCreateWithoutClientReviewInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    ExpertReview?: ExpertReviewCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutClientReviewInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ExpertReview?: ExpertReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutClientReviewInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutClientReviewInput, ExpertUncheckedCreateWithoutClientReviewInput>
  }

  export type AppointmentUpsertWithoutReceivedClientReviewsInput = {
    update: XOR<AppointmentUpdateWithoutReceivedClientReviewsInput, AppointmentUncheckedUpdateWithoutReceivedClientReviewsInput>
    create: XOR<AppointmentCreateWithoutReceivedClientReviewsInput, AppointmentUncheckedCreateWithoutReceivedClientReviewsInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutReceivedClientReviewsInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutReceivedClientReviewsInput, AppointmentUncheckedUpdateWithoutReceivedClientReviewsInput>
  }

  export type AppointmentUpdateWithoutReceivedClientReviewsInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    client?: UserUpdateOneRequiredWithoutAppointmentNestedInput
    expert?: ExpertUpdateOneRequiredWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutReceivedClientReviewsInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    writtenExpertReviews?: ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserUpsertWithoutReceivedClientReviewsInput = {
    update: XOR<UserUpdateWithoutReceivedClientReviewsInput, UserUncheckedUpdateWithoutReceivedClientReviewsInput>
    create: XOR<UserCreateWithoutReceivedClientReviewsInput, UserUncheckedCreateWithoutReceivedClientReviewsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutReceivedClientReviewsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutReceivedClientReviewsInput, UserUncheckedUpdateWithoutReceivedClientReviewsInput>
  }

  export type UserUpdateWithoutReceivedClientReviewsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutReceivedClientReviewsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertUpsertWithoutClientReviewInput = {
    update: XOR<ExpertUpdateWithoutClientReviewInput, ExpertUncheckedUpdateWithoutClientReviewInput>
    create: XOR<ExpertCreateWithoutClientReviewInput, ExpertUncheckedCreateWithoutClientReviewInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutClientReviewInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutClientReviewInput, ExpertUncheckedUpdateWithoutClientReviewInput>
  }

  export type ExpertUpdateWithoutClientReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutClientReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ExpertReview?: ExpertReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type AppointmentCreateWithoutWrittenExpertReviewsInput = {
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    client: UserCreateNestedOneWithoutAppointmentInput
    expert: ExpertCreateNestedOneWithoutAppointmentInput
    receivedClientReviews?: ClientReviewCreateNestedOneWithoutAppointmentInput
    reply?: ReplyCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutWrittenExpertReviewsInput = {
    id?: number
    clientId: string
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
    receivedClientReviews?: ClientReviewUncheckedCreateNestedOneWithoutAppointmentInput
    reply?: ReplyUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutWrittenExpertReviewsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutWrittenExpertReviewsInput, AppointmentUncheckedCreateWithoutWrittenExpertReviewsInput>
  }

  export type UserCreateWithoutWrittenExpertReviewsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutWrittenExpertReviewsInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutWrittenExpertReviewsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutWrittenExpertReviewsInput, UserUncheckedCreateWithoutWrittenExpertReviewsInput>
  }

  export type ExpertCreateWithoutExpertReviewInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityCreateNestedManyWithoutExpertInput
    Chat?: ChatCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewCreateNestedManyWithoutExpertInput
    User: UserCreateNestedOneWithoutExpertInput
    StripeAccount?: StripeAccountCreateNestedOneWithoutExpertInput
  }

  export type ExpertUncheckedCreateWithoutExpertReviewInput = {
    id?: string
    stripeAccountId?: number | null
    rate?: string
    timezone?: string
    user_id: string
    isAccepted?: boolean
    countryOfResidenceId?: number | null
    created_at?: Date | string | null
    firstName?: string
    lastName?: string
    email?: string | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutExpertInput
    Availabilities?: AvailabilityUncheckedCreateNestedManyWithoutExpertInput
    Chat?: ChatUncheckedCreateNestedManyWithoutExpertInput
    ChatMessage?: ChatMessageUncheckedCreateNestedManyWithoutExpertInput
    ClientReview?: ClientReviewUncheckedCreateNestedManyWithoutExpertInput
    StripeAccount?: StripeAccountUncheckedCreateNestedOneWithoutExpertInput
  }

  export type ExpertCreateOrConnectWithoutExpertReviewInput = {
    where: ExpertWhereUniqueInput
    create: XOR<ExpertCreateWithoutExpertReviewInput, ExpertUncheckedCreateWithoutExpertReviewInput>
  }

  export type AppointmentUpsertWithoutWrittenExpertReviewsInput = {
    update: XOR<AppointmentUpdateWithoutWrittenExpertReviewsInput, AppointmentUncheckedUpdateWithoutWrittenExpertReviewsInput>
    create: XOR<AppointmentCreateWithoutWrittenExpertReviewsInput, AppointmentUncheckedCreateWithoutWrittenExpertReviewsInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutWrittenExpertReviewsInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutWrittenExpertReviewsInput, AppointmentUncheckedUpdateWithoutWrittenExpertReviewsInput>
  }

  export type AppointmentUpdateWithoutWrittenExpertReviewsInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    client?: UserUpdateOneRequiredWithoutAppointmentNestedInput
    expert?: ExpertUpdateOneRequiredWithoutAppointmentNestedInput
    receivedClientReviews?: ClientReviewUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutWrittenExpertReviewsInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    receivedClientReviews?: ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserUpsertWithoutWrittenExpertReviewsInput = {
    update: XOR<UserUpdateWithoutWrittenExpertReviewsInput, UserUncheckedUpdateWithoutWrittenExpertReviewsInput>
    create: XOR<UserCreateWithoutWrittenExpertReviewsInput, UserUncheckedCreateWithoutWrittenExpertReviewsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutWrittenExpertReviewsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutWrittenExpertReviewsInput, UserUncheckedUpdateWithoutWrittenExpertReviewsInput>
  }

  export type UserUpdateWithoutWrittenExpertReviewsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutWrittenExpertReviewsInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExpertUpsertWithoutExpertReviewInput = {
    update: XOR<ExpertUpdateWithoutExpertReviewInput, ExpertUncheckedUpdateWithoutExpertReviewInput>
    create: XOR<ExpertCreateWithoutExpertReviewInput, ExpertUncheckedCreateWithoutExpertReviewInput>
    where?: ExpertWhereInput
  }

  export type ExpertUpdateToOneWithWhereWithoutExpertReviewInput = {
    where?: ExpertWhereInput
    data: XOR<ExpertUpdateWithoutExpertReviewInput, ExpertUncheckedUpdateWithoutExpertReviewInput>
  }

  export type ExpertUpdateWithoutExpertReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUpdateManyWithoutExpertNestedInput
    Chat?: ChatUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUpdateManyWithoutExpertNestedInput
    User?: UserUpdateOneRequiredWithoutExpertNestedInput
    StripeAccount?: StripeAccountUpdateOneWithoutExpertNestedInput
  }

  export type ExpertUncheckedUpdateWithoutExpertReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeAccountId?: NullableIntFieldUpdateOperationsInput | number | null
    rate?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    isAccepted?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutExpertNestedInput
    Availabilities?: AvailabilityUncheckedUpdateManyWithoutExpertNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutExpertNestedInput
    ChatMessage?: ChatMessageUncheckedUpdateManyWithoutExpertNestedInput
    ClientReview?: ClientReviewUncheckedUpdateManyWithoutExpertNestedInput
    StripeAccount?: StripeAccountUncheckedUpdateOneWithoutExpertNestedInput
  }

  export type UserCreateWithoutAdmin_userInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAdmin_userInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAdmin_userInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAdmin_userInput, UserUncheckedCreateWithoutAdmin_userInput>
  }

  export type UserUpsertWithoutAdmin_userInput = {
    update: XOR<UserUpdateWithoutAdmin_userInput, UserUncheckedUpdateWithoutAdmin_userInput>
    create: XOR<UserCreateWithoutAdmin_userInput, UserUncheckedCreateWithoutAdmin_userInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAdmin_userInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAdmin_userInput, UserUncheckedUpdateWithoutAdmin_userInput>
  }

  export type UserUpdateWithoutAdmin_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAdmin_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSessionInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionInput, UserUncheckedCreateWithoutSessionInput>
  }

  export type UserUpsertWithoutSessionInput = {
    update: XOR<UserUpdateWithoutSessionInput, UserUncheckedUpdateWithoutSessionInput>
    create: XOR<UserCreateWithoutSessionInput, UserUncheckedCreateWithoutSessionInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionInput, UserUncheckedUpdateWithoutSessionInput>
  }

  export type UserUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type admin_expert_applicationCreateWithoutAnswerInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    User: UserCreateNestedOneWithoutAdmin_expert_applicationInput
  }

  export type admin_expert_applicationUncheckedCreateWithoutAnswerInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
    userId: string
  }

  export type admin_expert_applicationCreateOrConnectWithoutAnswerInput = {
    where: admin_expert_applicationWhereUniqueInput
    create: XOR<admin_expert_applicationCreateWithoutAnswerInput, admin_expert_applicationUncheckedCreateWithoutAnswerInput>
  }

  export type expertApplicationQuestionCreateWithoutExpertApplicationAnswerInput = {
    id: string
    question: string
    created_at?: Date | string
    order?: number
  }

  export type expertApplicationQuestionUncheckedCreateWithoutExpertApplicationAnswerInput = {
    id: string
    question: string
    created_at?: Date | string
    order?: number
  }

  export type expertApplicationQuestionCreateOrConnectWithoutExpertApplicationAnswerInput = {
    where: expertApplicationQuestionWhereUniqueInput
    create: XOR<expertApplicationQuestionCreateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedCreateWithoutExpertApplicationAnswerInput>
  }

  export type UserCreateWithoutExpertApplicationAnswerInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutExpertApplicationAnswerInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_expert_application?: admin_expert_applicationUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutExpertApplicationAnswerInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutExpertApplicationAnswerInput, UserUncheckedCreateWithoutExpertApplicationAnswerInput>
  }

  export type admin_expert_applicationUpsertWithoutAnswerInput = {
    update: XOR<admin_expert_applicationUpdateWithoutAnswerInput, admin_expert_applicationUncheckedUpdateWithoutAnswerInput>
    create: XOR<admin_expert_applicationCreateWithoutAnswerInput, admin_expert_applicationUncheckedCreateWithoutAnswerInput>
    where?: admin_expert_applicationWhereInput
  }

  export type admin_expert_applicationUpdateToOneWithWhereWithoutAnswerInput = {
    where?: admin_expert_applicationWhereInput
    data: XOR<admin_expert_applicationUpdateWithoutAnswerInput, admin_expert_applicationUncheckedUpdateWithoutAnswerInput>
  }

  export type admin_expert_applicationUpdateWithoutAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutAdmin_expert_applicationNestedInput
  }

  export type admin_expert_applicationUncheckedUpdateWithoutAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type expertApplicationQuestionUpsertWithoutExpertApplicationAnswerInput = {
    update: XOR<expertApplicationQuestionUpdateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedUpdateWithoutExpertApplicationAnswerInput>
    create: XOR<expertApplicationQuestionCreateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedCreateWithoutExpertApplicationAnswerInput>
    where?: expertApplicationQuestionWhereInput
  }

  export type expertApplicationQuestionUpdateToOneWithWhereWithoutExpertApplicationAnswerInput = {
    where?: expertApplicationQuestionWhereInput
    data: XOR<expertApplicationQuestionUpdateWithoutExpertApplicationAnswerInput, expertApplicationQuestionUncheckedUpdateWithoutExpertApplicationAnswerInput>
  }

  export type expertApplicationQuestionUpdateWithoutExpertApplicationAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
  }

  export type expertApplicationQuestionUncheckedUpdateWithoutExpertApplicationAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: IntFieldUpdateOperationsInput | number
  }

  export type UserUpsertWithoutExpertApplicationAnswerInput = {
    update: XOR<UserUpdateWithoutExpertApplicationAnswerInput, UserUncheckedUpdateWithoutExpertApplicationAnswerInput>
    create: XOR<UserCreateWithoutExpertApplicationAnswerInput, UserUncheckedCreateWithoutExpertApplicationAnswerInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutExpertApplicationAnswerInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutExpertApplicationAnswerInput, UserUncheckedUpdateWithoutExpertApplicationAnswerInput>
  }

  export type UserUpdateWithoutExpertApplicationAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutExpertApplicationAnswerInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_expert_application?: admin_expert_applicationUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutAdmin_expert_applicationInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityCreateNestedManyWithoutUserInput
    Chat?: ChatCreateNestedManyWithoutClientInput
    messages?: ChatMessageCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewCreateNestedManyWithoutClientInput
    educations?: EducationCreateNestedManyWithoutUserInput
    experiences?: ExperienceCreateNestedManyWithoutUserInput
    Expert?: ExpertCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewCreateNestedManyWithoutClientInput
    expertises?: ExpertiseCreateNestedManyWithoutUserInput
    key?: KeyCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageCreateNestedManyWithoutUserInput
    Questions?: QuestionCreateNestedManyWithoutUserInput
    reply?: ReplyCreateNestedManyWithoutUserInput
    admin_user?: admin_userCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerCreateNestedManyWithoutUserInput
    id_verification?: id_verificationCreateNestedManyWithoutUserInput
    session?: sessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAdmin_expert_applicationInput = {
    id: string
    firstName?: string | null
    lastName?: string | null
    email: string
    imageUrl?: string | null
    imageName?: string | null
    customer_id?: string | null
    phone?: string | null
    follower?: number | null
    role?: string | null
    state?: string | null
    city?: string | null
    zipcode?: string | null
    timezone?: string | null
    rate?: string | null
    countryOfResidence?: string | null
    biography?: string | null
    linkedInURL?: string | null
    instagramURL?: string | null
    youtubeURL?: string | null
    spotifyURL?: string | null
    tiktokURL?: string | null
    twitterURL?: string | null
    amazonURL?: string | null
    websiteURL1?: string | null
    websiteURL2?: string | null
    createdAt?: Date | string
    refresh_token?: string | null
    isExpert?: boolean
    videos?: UserCreatevideosInput | string[]
    expertId?: string
    provider?: string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: number | null
    userName?: string | null
    isBanned?: boolean
    isAdmin?: boolean
    isSubscribed?: boolean
    countryOfResidenceISO?: $Enums.CountryCode
    countryOfResidenceId?: number | null
    dateOfBirth?: Date | string | null
    emailVerified?: boolean
    idVerified?: boolean
    FavoriteExpertIds?: UserCreateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutClientInput
    availabilities?: AvailabilityUncheckedCreateNestedManyWithoutUserInput
    Chat?: ChatUncheckedCreateNestedManyWithoutClientInput
    messages?: ChatMessageUncheckedCreateNestedManyWithoutSenderInput
    receivedClientReviews?: ClientReviewUncheckedCreateNestedManyWithoutClientInput
    educations?: EducationUncheckedCreateNestedManyWithoutUserInput
    experiences?: ExperienceUncheckedCreateNestedManyWithoutUserInput
    Expert?: ExpertUncheckedCreateNestedOneWithoutUserInput
    writtenExpertReviews?: ExpertReviewUncheckedCreateNestedManyWithoutClientInput
    expertises?: ExpertiseUncheckedCreateNestedManyWithoutUserInput
    key?: KeyUncheckedCreateNestedManyWithoutUserInput
    languagesSpoken?: LanguageUncheckedCreateNestedManyWithoutUserInput
    Questions?: QuestionUncheckedCreateNestedManyWithoutUserInput
    reply?: ReplyUncheckedCreateNestedManyWithoutUserInput
    admin_user?: admin_userUncheckedCreateNestedOneWithoutUserInput
    email_verification_token?: email_verification_tokenUncheckedCreateNestedManyWithoutUserInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedCreateNestedManyWithoutUserInput
    id_verification?: id_verificationUncheckedCreateNestedManyWithoutUserInput
    session?: sessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAdmin_expert_applicationInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAdmin_expert_applicationInput, UserUncheckedCreateWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput = {
    id?: string
    answer: string
    created_at?: Date | string
    expertApplicationQuestion: expertApplicationQuestionCreateNestedOneWithoutExpertApplicationAnswerInput
    User: UserCreateNestedOneWithoutExpertApplicationAnswerInput
  }

  export type expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    questionId: string
  }

  export type expertApplicationAnswerCreateOrConnectWithoutAdmin_expert_applicationInput = {
    where: expertApplicationAnswerWhereUniqueInput
    create: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerCreateManyAdmin_expert_applicationInputEnvelope = {
    data: expertApplicationAnswerCreateManyAdmin_expert_applicationInput | expertApplicationAnswerCreateManyAdmin_expert_applicationInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutAdmin_expert_applicationInput = {
    update: XOR<UserUpdateWithoutAdmin_expert_applicationInput, UserUncheckedUpdateWithoutAdmin_expert_applicationInput>
    create: XOR<UserCreateWithoutAdmin_expert_applicationInput, UserUncheckedCreateWithoutAdmin_expert_applicationInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAdmin_expert_applicationInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAdmin_expert_applicationInput, UserUncheckedUpdateWithoutAdmin_expert_applicationInput>
  }

  export type UserUpdateWithoutAdmin_expert_applicationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUpdateManyWithoutUserNestedInput
    Chat?: ChatUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUpdateManyWithoutClientNestedInput
    educations?: EducationUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUpdateManyWithoutUserNestedInput
    Expert?: ExpertUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUpdateManyWithoutUserNestedInput
    key?: KeyUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUpdateManyWithoutUserNestedInput
    Questions?: QuestionUpdateManyWithoutUserNestedInput
    reply?: ReplyUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUpdateManyWithoutUserNestedInput
    session?: sessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAdmin_expert_applicationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    imageName?: NullableStringFieldUpdateOperationsInput | string | null
    customer_id?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    follower?: NullableIntFieldUpdateOperationsInput | number | null
    role?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipcode?: NullableStringFieldUpdateOperationsInput | string | null
    timezone?: NullableStringFieldUpdateOperationsInput | string | null
    rate?: NullableStringFieldUpdateOperationsInput | string | null
    countryOfResidence?: NullableStringFieldUpdateOperationsInput | string | null
    biography?: NullableStringFieldUpdateOperationsInput | string | null
    linkedInURL?: NullableStringFieldUpdateOperationsInput | string | null
    instagramURL?: NullableStringFieldUpdateOperationsInput | string | null
    youtubeURL?: NullableStringFieldUpdateOperationsInput | string | null
    spotifyURL?: NullableStringFieldUpdateOperationsInput | string | null
    tiktokURL?: NullableStringFieldUpdateOperationsInput | string | null
    twitterURL?: NullableStringFieldUpdateOperationsInput | string | null
    amazonURL?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL1?: NullableStringFieldUpdateOperationsInput | string | null
    websiteURL2?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    isExpert?: BoolFieldUpdateOperationsInput | boolean
    videos?: UserUpdatevideosInput | string[]
    expertId?: StringFieldUpdateOperationsInput | string
    provider?: NullableStringFieldUpdateOperationsInput | string | null
    otherInfo?: NullableJsonNullValueInput | InputJsonValue
    is_invited?: NullableIntFieldUpdateOperationsInput | number | null
    userName?: NullableStringFieldUpdateOperationsInput | string | null
    isBanned?: BoolFieldUpdateOperationsInput | boolean
    isAdmin?: BoolFieldUpdateOperationsInput | boolean
    isSubscribed?: BoolFieldUpdateOperationsInput | boolean
    countryOfResidenceISO?: EnumCountryCodeFieldUpdateOperationsInput | $Enums.CountryCode
    countryOfResidenceId?: NullableIntFieldUpdateOperationsInput | number | null
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    idVerified?: BoolFieldUpdateOperationsInput | boolean
    FavoriteExpertIds?: UserUpdateFavoriteExpertIdsInput | string[]
    Appointment?: AppointmentUncheckedUpdateManyWithoutClientNestedInput
    availabilities?: AvailabilityUncheckedUpdateManyWithoutUserNestedInput
    Chat?: ChatUncheckedUpdateManyWithoutClientNestedInput
    messages?: ChatMessageUncheckedUpdateManyWithoutSenderNestedInput
    receivedClientReviews?: ClientReviewUncheckedUpdateManyWithoutClientNestedInput
    educations?: EducationUncheckedUpdateManyWithoutUserNestedInput
    experiences?: ExperienceUncheckedUpdateManyWithoutUserNestedInput
    Expert?: ExpertUncheckedUpdateOneWithoutUserNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateManyWithoutClientNestedInput
    expertises?: ExpertiseUncheckedUpdateManyWithoutUserNestedInput
    key?: KeyUncheckedUpdateManyWithoutUserNestedInput
    languagesSpoken?: LanguageUncheckedUpdateManyWithoutUserNestedInput
    Questions?: QuestionUncheckedUpdateManyWithoutUserNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutUserNestedInput
    admin_user?: admin_userUncheckedUpdateOneWithoutUserNestedInput
    email_verification_token?: email_verification_tokenUncheckedUpdateManyWithoutUserNestedInput
    expertApplicationAnswer?: expertApplicationAnswerUncheckedUpdateManyWithoutUserNestedInput
    id_verification?: id_verificationUncheckedUpdateManyWithoutUserNestedInput
    session?: sessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type expertApplicationAnswerUpsertWithWhereUniqueWithoutAdmin_expert_applicationInput = {
    where: expertApplicationAnswerWhereUniqueInput
    update: XOR<expertApplicationAnswerUpdateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedUpdateWithoutAdmin_expert_applicationInput>
    create: XOR<expertApplicationAnswerCreateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedCreateWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerUpdateWithWhereUniqueWithoutAdmin_expert_applicationInput = {
    where: expertApplicationAnswerWhereUniqueInput
    data: XOR<expertApplicationAnswerUpdateWithoutAdmin_expert_applicationInput, expertApplicationAnswerUncheckedUpdateWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerUpdateManyWithWhereWithoutAdmin_expert_applicationInput = {
    where: expertApplicationAnswerScalarWhereInput
    data: XOR<expertApplicationAnswerUpdateManyMutationInput, expertApplicationAnswerUncheckedUpdateManyWithoutAdmin_expert_applicationInput>
  }

  export type expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput = {
    id?: string
    answer: string
    created_at?: Date | string
    admin_expert_application?: admin_expert_applicationCreateNestedOneWithoutAnswerInput
    User: UserCreateNestedOneWithoutExpertApplicationAnswerInput
  }

  export type expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    admin_expert_applicationId?: string | null
  }

  export type expertApplicationAnswerCreateOrConnectWithoutExpertApplicationQuestionInput = {
    where: expertApplicationAnswerWhereUniqueInput
    create: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput>
  }

  export type expertApplicationAnswerCreateManyExpertApplicationQuestionInputEnvelope = {
    data: expertApplicationAnswerCreateManyExpertApplicationQuestionInput | expertApplicationAnswerCreateManyExpertApplicationQuestionInput[]
    skipDuplicates?: boolean
  }

  export type expertApplicationAnswerUpsertWithWhereUniqueWithoutExpertApplicationQuestionInput = {
    where: expertApplicationAnswerWhereUniqueInput
    update: XOR<expertApplicationAnswerUpdateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedUpdateWithoutExpertApplicationQuestionInput>
    create: XOR<expertApplicationAnswerCreateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedCreateWithoutExpertApplicationQuestionInput>
  }

  export type expertApplicationAnswerUpdateWithWhereUniqueWithoutExpertApplicationQuestionInput = {
    where: expertApplicationAnswerWhereUniqueInput
    data: XOR<expertApplicationAnswerUpdateWithoutExpertApplicationQuestionInput, expertApplicationAnswerUncheckedUpdateWithoutExpertApplicationQuestionInput>
  }

  export type expertApplicationAnswerUpdateManyWithWhereWithoutExpertApplicationQuestionInput = {
    where: expertApplicationAnswerScalarWhereInput
    data: XOR<expertApplicationAnswerUpdateManyMutationInput, expertApplicationAnswerUncheckedUpdateManyWithoutExpertApplicationQuestionInput>
  }

  export type AppointmentCreateManyClientInput = {
    id?: number
    clientEmail?: string
    expertId: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
  }

  export type AvailabilityCreateManyUserInput = {
    id?: number
    day: string
    timezone: string
    expertId: string
  }

  export type ChatCreateManyClientInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    expertId: string
  }

  export type ChatMessageCreateManySenderInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    expertId?: string | null
  }

  export type ClientReviewCreateManyClientInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    expertId: string
  }

  export type EducationCreateManyUserInput = {
    id?: number
    institutionName: string
    diplomaTitle: string
    fieldOfStudy: string
    isCurrent?: boolean
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type ExperienceCreateManyUserInput = {
    id?: number
    companyName: string
    role: string
    isCurrent?: boolean
    duration: string
    description: string
    endDate?: Date | string | null
    startDate?: Date | string | null
  }

  export type ExpertReviewCreateManyClientInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    expertId: string
    appointmentKey: string
    isDisplayed?: boolean
  }

  export type ExpertiseCreateManyUserInput = {
    id?: number
    field: string
    isCurrent?: boolean
    description: string
    duration: string
    startDate?: Date | string | null
    endDate?: Date | string | null
  }

  export type KeyCreateManyUserInput = {
    id: string
    hashed_password?: string | null
  }

  export type LanguageCreateManyUserInput = {
    id?: number
    name?: string
  }

  export type QuestionCreateManyUserInput = {
    id?: number
    content: string
  }

  export type ReplyCreateManyUserInput = {
    id?: number
    content: string
    appointmentKey: string
    questionContent: string
  }

  export type admin_expert_applicationCreateManyUserInput = {
    id?: string
    status?: $Enums.Status
    createdAt?: Date | string
  }

  export type email_verification_tokenCreateManyUserInput = {
    id: string
    expires: bigint | number
  }

  export type expertApplicationAnswerCreateManyUserInput = {
    id?: string
    answer: string
    created_at?: Date | string
    questionId: string
    admin_expert_applicationId?: string | null
  }

  export type id_verificationCreateManyUserInput = {
    id?: number
    status?: $Enums.Status
    idImageUrlBack?: string | null
    idImageUrlFront: string
    createdAt?: Date | string
    documentType?: $Enums.documentType
  }

  export type sessionCreateManyUserInput = {
    id: string
    active_expires: bigint | number
    idle_expires: bigint | number
  }

  export type AppointmentUpdateWithoutClientInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    expert?: ExpertUpdateOneRequiredWithoutAppointmentNestedInput
    receivedClientReviews?: ClientReviewUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    receivedClientReviews?: ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateManyWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientEmail?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AvailabilityUpdateWithoutUserInput = {
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expert?: ExpertUpdateOneRequiredWithoutAvailabilitiesNestedInput
    slots?: SlotUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    slots?: SlotUncheckedUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatUpdateWithoutClientInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expert?: ExpertUpdateOneRequiredWithoutChatNestedInput
    messages?: ChatMessageUpdateManyWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateWithoutClientInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expertId?: StringFieldUpdateOperationsInput | string
    messages?: ChatMessageUncheckedUpdateManyWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateManyWithoutClientInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatMessageUpdateWithoutSenderInput = {
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chat?: ChatUpdateOneRequiredWithoutMessagesNestedInput
    Expert?: ExpertUpdateOneWithoutChatMessageNestedInput
  }

  export type ChatMessageUncheckedUpdateWithoutSenderInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatMessageUncheckedUpdateManyWithoutSenderInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClientReviewUpdateWithoutClientInput = {
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutClientReviewNestedInput
  }

  export type ClientReviewUncheckedUpdateWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type ClientReviewUncheckedUpdateManyWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    expertId?: StringFieldUpdateOperationsInput | string
  }

  export type EducationUpdateWithoutUserInput = {
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type EducationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type EducationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    institutionName?: StringFieldUpdateOperationsInput | string
    diplomaTitle?: StringFieldUpdateOperationsInput | string
    fieldOfStudy?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExperienceUpdateWithoutUserInput = {
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExperienceUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExperienceUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    companyName?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    duration?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertReviewUpdateWithoutClientInput = {
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
    expert?: ExpertUpdateOneRequiredWithoutExpertReviewNestedInput
  }

  export type ExpertReviewUncheckedUpdateWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ExpertReviewUncheckedUpdateManyWithoutClientInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    expertId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ExpertiseUpdateWithoutUserInput = {
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertiseUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ExpertiseUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    field?: StringFieldUpdateOperationsInput | string
    isCurrent?: BoolFieldUpdateOperationsInput | boolean
    description?: StringFieldUpdateOperationsInput | string
    duration?: StringFieldUpdateOperationsInput | string
    startDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type KeyUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type KeyUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type KeyUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    hashed_password?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type LanguageUpdateWithoutUserInput = {
    name?: StringFieldUpdateOperationsInput | string
  }

  export type LanguageUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
  }

  export type LanguageUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionUpdateWithoutUserInput = {
    content?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
  }

  export type QuestionUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyUpdateWithoutUserInput = {
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    appointment?: AppointmentUpdateOneRequiredWithoutReplyNestedInput
  }

  export type ReplyUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
  }

  export type admin_expert_applicationUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    answer?: expertApplicationAnswerUpdateManyWithoutAdmin_expert_applicationNestedInput
  }

  export type admin_expert_applicationUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    answer?: expertApplicationAnswerUncheckedUpdateManyWithoutAdmin_expert_applicationNestedInput
  }

  export type admin_expert_applicationUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type email_verification_tokenUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type email_verification_tokenUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type email_verification_tokenUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type expertApplicationAnswerUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    admin_expert_application?: admin_expert_applicationUpdateOneWithoutAnswerNestedInput
    expertApplicationQuestion?: expertApplicationQuestionUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
  }

  export type expertApplicationAnswerUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    questionId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    questionId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type id_verificationUpdateWithoutUserInput = {
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type id_verificationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type id_verificationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    status?: EnumStatusFieldUpdateOperationsInput | $Enums.Status
    idImageUrlBack?: NullableStringFieldUpdateOperationsInput | string | null
    idImageUrlFront?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    documentType?: EnumdocumentTypeFieldUpdateOperationsInput | $Enums.documentType
  }

  export type sessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type sessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type sessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    active_expires?: BigIntFieldUpdateOperationsInput | bigint | number
    idle_expires?: BigIntFieldUpdateOperationsInput | bigint | number
  }

  export type AppointmentCreateManyExpertInput = {
    id?: number
    clientId: string
    clientEmail?: string
    clientName?: string
    expertName?: string
    isAcceptedByExpert?: string
    price: string
    timezone: string
    date: number
    dayName: string
    time: string
    text?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    paymentStatus?: string
    paymentIntentId?: string
    sessionId?: string
    authorizedDate?: string
    appointementKeyInExpertTimeZone: string
    appointementKeyInClientTimeZone: string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status: string
    reason?: string | null
  }

  export type AvailabilityCreateManyExpertInput = {
    id?: number
    day: string
    timezone: string
    userId?: string | null
  }

  export type ChatCreateManyExpertInput = {
    id: string
    createdAt?: Date | string
    updatedAt?: Date | string
    clientId: string
  }

  export type ChatMessageCreateManyExpertInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    chatId: string
    senderId: string
  }

  export type ClientReviewCreateManyExpertInput = {
    id?: number
    reviewText: string
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type ExpertReviewCreateManyExpertInput = {
    id?: number
    reviewText?: string | null
    createdAt?: Date | string
    videoRoomId: string
    appointmentKey: string
    isDisplayed?: boolean
    clientId: string
  }

  export type AppointmentUpdateWithoutExpertInput = {
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    client?: UserUpdateOneRequiredWithoutAppointmentNestedInput
    receivedClientReviews?: ClientReviewUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    receivedClientReviews?: ClientReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    writtenExpertReviews?: ExpertReviewUncheckedUpdateOneWithoutAppointmentNestedInput
    reply?: ReplyUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateManyWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    clientId?: StringFieldUpdateOperationsInput | string
    clientEmail?: StringFieldUpdateOperationsInput | string
    clientName?: StringFieldUpdateOperationsInput | string
    expertName?: StringFieldUpdateOperationsInput | string
    isAcceptedByExpert?: StringFieldUpdateOperationsInput | string
    price?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    date?: IntFieldUpdateOperationsInput | number
    dayName?: StringFieldUpdateOperationsInput | string
    time?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    paymentStatus?: StringFieldUpdateOperationsInput | string
    paymentIntentId?: StringFieldUpdateOperationsInput | string
    sessionId?: StringFieldUpdateOperationsInput | string
    authorizedDate?: StringFieldUpdateOperationsInput | string
    appointementKeyInExpertTimeZone?: StringFieldUpdateOperationsInput | string
    appointementKeyInClientTimeZone?: StringFieldUpdateOperationsInput | string
    bookedAppointments?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AvailabilityUpdateWithoutExpertInput = {
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneWithoutAvailabilitiesNestedInput
    slots?: SlotUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    slots?: SlotUncheckedUpdateManyWithoutAvailabilityNestedInput
  }

  export type AvailabilityUncheckedUpdateManyWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    day?: StringFieldUpdateOperationsInput | string
    timezone?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatUpdateWithoutExpertInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    client?: UserUpdateOneRequiredWithoutChatNestedInput
    messages?: ChatMessageUpdateManyWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateWithoutExpertInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    clientId?: StringFieldUpdateOperationsInput | string
    messages?: ChatMessageUncheckedUpdateManyWithoutChatNestedInput
  }

  export type ChatUncheckedUpdateManyWithoutExpertInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatMessageUpdateWithoutExpertInput = {
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chat?: ChatUpdateOneRequiredWithoutMessagesNestedInput
    sender?: UserUpdateOneRequiredWithoutMessagesNestedInput
  }

  export type ChatMessageUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
  }

  export type ChatMessageUncheckedUpdateManyWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chatId?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
  }

  export type ClientReviewUpdateWithoutExpertInput = {
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
    client?: UserUpdateOneRequiredWithoutReceivedClientReviewsNestedInput
  }

  export type ClientReviewUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ClientReviewUncheckedUpdateManyWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertReviewUpdateWithoutExpertInput = {
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    appointment?: AppointmentUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
    client?: UserUpdateOneRequiredWithoutWrittenExpertReviewsNestedInput
  }

  export type ExpertReviewUncheckedUpdateWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertReviewUncheckedUpdateManyWithoutExpertInput = {
    id?: IntFieldUpdateOperationsInput | number
    reviewText?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    videoRoomId?: StringFieldUpdateOperationsInput | string
    appointmentKey?: StringFieldUpdateOperationsInput | string
    isDisplayed?: BoolFieldUpdateOperationsInput | boolean
    clientId?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyCreateManyAppointmentInput = {
    id?: number
    content: string
    questionContent: string
    userId: string
  }

  export type ReplyUpdateWithoutAppointmentInput = {
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutReplyNestedInput
  }

  export type ReplyUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ReplyUncheckedUpdateManyWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    questionContent?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type SlotCreateManyAvailabilityInput = {
    id: string
    start: string
    end: string
    recurring?: boolean
    hide?: boolean
    isSplit?: boolean
    originalId: string
  }

  export type SlotUpdateWithoutAvailabilityInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
    exceptions?: ExceptionUpdateManyWithoutSlotNestedInput
  }

  export type SlotUncheckedUpdateWithoutAvailabilityInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
    exceptions?: ExceptionUncheckedUpdateManyWithoutSlotNestedInput
  }

  export type SlotUncheckedUpdateManyWithoutAvailabilityInput = {
    id?: StringFieldUpdateOperationsInput | string
    start?: StringFieldUpdateOperationsInput | string
    end?: StringFieldUpdateOperationsInput | string
    recurring?: BoolFieldUpdateOperationsInput | boolean
    hide?: BoolFieldUpdateOperationsInput | boolean
    isSplit?: BoolFieldUpdateOperationsInput | boolean
    originalId?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionCreateManySlotInput = {
    id?: number
    date: string
  }

  export type ExceptionUpdateWithoutSlotInput = {
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionUncheckedUpdateWithoutSlotInput = {
    id?: IntFieldUpdateOperationsInput | number
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ExceptionUncheckedUpdateManyWithoutSlotInput = {
    id?: IntFieldUpdateOperationsInput | number
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChatMessageCreateManyChatInput = {
    id?: number
    content: string
    userId: string
    fileName: string
    type: string
    fileType: string
    fileUrl?: string
    createdAt?: Date | string
    senderId: string
    expertId?: string | null
  }

  export type ChatMessageUpdateWithoutChatInput = {
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Expert?: ExpertUpdateOneWithoutChatMessageNestedInput
    sender?: UserUpdateOneRequiredWithoutMessagesNestedInput
  }

  export type ChatMessageUncheckedUpdateWithoutChatInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    senderId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatMessageUncheckedUpdateManyWithoutChatInput = {
    id?: IntFieldUpdateOperationsInput | number
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    fileName?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    fileType?: StringFieldUpdateOperationsInput | string
    fileUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    senderId?: StringFieldUpdateOperationsInput | string
    expertId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type expertApplicationAnswerCreateManyAdmin_expert_applicationInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    questionId: string
  }

  export type expertApplicationAnswerUpdateWithoutAdmin_expert_applicationInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    expertApplicationQuestion?: expertApplicationQuestionUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
    User?: UserUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
  }

  export type expertApplicationAnswerUncheckedUpdateWithoutAdmin_expert_applicationInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    questionId?: StringFieldUpdateOperationsInput | string
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutAdmin_expert_applicationInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    questionId?: StringFieldUpdateOperationsInput | string
  }

  export type expertApplicationAnswerCreateManyExpertApplicationQuestionInput = {
    id?: string
    answer: string
    created_at?: Date | string
    userId: string
    admin_expert_applicationId?: string | null
  }

  export type expertApplicationAnswerUpdateWithoutExpertApplicationQuestionInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    admin_expert_application?: admin_expert_applicationUpdateOneWithoutAnswerNestedInput
    User?: UserUpdateOneRequiredWithoutExpertApplicationAnswerNestedInput
  }

  export type expertApplicationAnswerUncheckedUpdateWithoutExpertApplicationQuestionInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type expertApplicationAnswerUncheckedUpdateManyWithoutExpertApplicationQuestionInput = {
    id?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    admin_expert_applicationId?: NullableStringFieldUpdateOperationsInput | string | null
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertCountOutputTypeDefaultArgs instead
     */
    export type ExpertCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentCountOutputTypeDefaultArgs instead
     */
    export type AppointmentCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AvailabilityCountOutputTypeDefaultArgs instead
     */
    export type AvailabilityCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AvailabilityCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SlotCountOutputTypeDefaultArgs instead
     */
    export type SlotCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SlotCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChatCountOutputTypeDefaultArgs instead
     */
    export type ChatCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChatCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use Admin_expert_applicationCountOutputTypeDefaultArgs instead
     */
    export type Admin_expert_applicationCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = Admin_expert_applicationCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertApplicationQuestionCountOutputTypeDefaultArgs instead
     */
    export type ExpertApplicationQuestionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertApplicationQuestionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertDefaultArgs instead
     */
    export type ExpertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertDefaultArgs<ExtArgs>
    /**
     * @deprecated Use id_verificationDefaultArgs instead
     */
    export type id_verificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = id_verificationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use email_verification_tokenDefaultArgs instead
     */
    export type email_verification_tokenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = email_verification_tokenDefaultArgs<ExtArgs>
    /**
     * @deprecated Use QuestionDefaultArgs instead
     */
    export type QuestionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = QuestionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ReplyDefaultArgs instead
     */
    export type ReplyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ReplyDefaultArgs<ExtArgs>
    /**
     * @deprecated Use StripeAccountDefaultArgs instead
     */
    export type StripeAccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = StripeAccountDefaultArgs<ExtArgs>
    /**
     * @deprecated Use KeyDefaultArgs instead
     */
    export type KeyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = KeyDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExperienceDefaultArgs instead
     */
    export type ExperienceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExperienceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EducationDefaultArgs instead
     */
    export type EducationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EducationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertiseDefaultArgs instead
     */
    export type ExpertiseArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertiseDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LanguageDefaultArgs instead
     */
    export type LanguageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LanguageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentDefaultArgs instead
     */
    export type AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AvailabilityDefaultArgs instead
     */
    export type AvailabilityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AvailabilityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SlotDefaultArgs instead
     */
    export type SlotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SlotDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExceptionDefaultArgs instead
     */
    export type ExceptionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExceptionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChatDefaultArgs instead
     */
    export type ChatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChatDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChatMessageDefaultArgs instead
     */
    export type ChatMessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChatMessageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ClientReviewDefaultArgs instead
     */
    export type ClientReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ClientReviewDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertReviewDefaultArgs instead
     */
    export type ExpertReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertReviewDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_invite_expertsDefaultArgs instead
     */
    export type admin_invite_expertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_invite_expertsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_mbc_cmsDefaultArgs instead
     */
    export type admin_mbc_cmsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_mbc_cmsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_mbc_faqsDefaultArgs instead
     */
    export type admin_mbc_faqsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_mbc_faqsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_newsletterDefaultArgs instead
     */
    export type admin_newsletterArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_newsletterDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_userDefaultArgs instead
     */
    export type admin_userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_userDefaultArgs<ExtArgs>
    /**
     * @deprecated Use faqQuestionDefaultArgs instead
     */
    export type faqQuestionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = faqQuestionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use sessionDefaultArgs instead
     */
    export type sessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = sessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_editingDefaultArgs instead
     */
    export type admin_editingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_editingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_notificationDefaultArgs instead
     */
    export type admin_notificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_notificationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_notification_statusDefaultArgs instead
     */
    export type admin_notification_statusArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_notification_statusDefaultArgs<ExtArgs>
    /**
     * @deprecated Use expertApplicationAnswerDefaultArgs instead
     */
    export type expertApplicationAnswerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = expertApplicationAnswerDefaultArgs<ExtArgs>
    /**
     * @deprecated Use admin_expert_applicationDefaultArgs instead
     */
    export type admin_expert_applicationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = admin_expert_applicationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use expertApplicationQuestionDefaultArgs instead
     */
    export type expertApplicationQuestionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = expertApplicationQuestionDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}