/**
 * Client
**/

import * as runtime from './runtime/client.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 Patient
 * 
 */
export type Patient = $Result.DefaultSelection<Prisma.$PatientPayload>
/**
 * Model Appointment
 * 
 */
export type Appointment = $Result.DefaultSelection<Prisma.$AppointmentPayload>
/**
 * Model AppointmentFile
 * 
 */
export type AppointmentFile = $Result.DefaultSelection<Prisma.$AppointmentFilePayload>
/**
 * Model Staff
 * 
 */
export type Staff = $Result.DefaultSelection<Prisma.$StaffPayload>
/**
 * Model NpiProvider
 * 
 */
export type NpiProvider = $Result.DefaultSelection<Prisma.$NpiProviderPayload>
/**
 * Model AppointmentProcedure
 * 
 */
export type AppointmentProcedure = $Result.DefaultSelection<Prisma.$AppointmentProcedurePayload>
/**
 * Model Claim
 * 
 */
export type Claim = $Result.DefaultSelection<Prisma.$ClaimPayload>
/**
 * Model ServiceLine
 * 
 */
export type ServiceLine = $Result.DefaultSelection<Prisma.$ServiceLinePayload>
/**
 * Model ClaimFile
 * 
 */
export type ClaimFile = $Result.DefaultSelection<Prisma.$ClaimFilePayload>
/**
 * Model InsuranceCredential
 * 
 */
export type InsuranceCredential = $Result.DefaultSelection<Prisma.$InsuranceCredentialPayload>
/**
 * Model ShoppingVendor
 * 
 */
export type ShoppingVendor = $Result.DefaultSelection<Prisma.$ShoppingVendorPayload>
/**
 * Model PdfGroup
 * 
 */
export type PdfGroup = $Result.DefaultSelection<Prisma.$PdfGroupPayload>
/**
 * Model PdfFile
 * 
 */
export type PdfFile = $Result.DefaultSelection<Prisma.$PdfFilePayload>
/**
 * Model Payment
 * 
 */
export type Payment = $Result.DefaultSelection<Prisma.$PaymentPayload>
/**
 * Model ServiceLineTransaction
 * 
 */
export type ServiceLineTransaction = $Result.DefaultSelection<Prisma.$ServiceLineTransactionPayload>
/**
 * Model DatabaseBackup
 * 
 */
export type DatabaseBackup = $Result.DefaultSelection<Prisma.$DatabaseBackupPayload>
/**
 * Model BackupDestination
 * 
 */
export type BackupDestination = $Result.DefaultSelection<Prisma.$BackupDestinationPayload>
/**
 * Model Notification
 * 
 */
export type Notification = $Result.DefaultSelection<Prisma.$NotificationPayload>
/**
 * Model CronJobLog
 * 
 */
export type CronJobLog = $Result.DefaultSelection<Prisma.$CronJobLogPayload>
/**
 * Model CloudFolder
 * 
 */
export type CloudFolder = $Result.DefaultSelection<Prisma.$CloudFolderPayload>
/**
 * Model CloudFile
 * 
 */
export type CloudFile = $Result.DefaultSelection<Prisma.$CloudFilePayload>
/**
 * Model CloudFileChunk
 * 
 */
export type CloudFileChunk = $Result.DefaultSelection<Prisma.$CloudFileChunkPayload>
/**
 * Model Communication
 * 
 */
export type Communication = $Result.DefaultSelection<Prisma.$CommunicationPayload>
/**
 * Model PatientDocument
 * 
 */
export type PatientDocument = $Result.DefaultSelection<Prisma.$PatientDocumentPayload>
/**
 * Model TwilioSettings
 * 
 */
export type TwilioSettings = $Result.DefaultSelection<Prisma.$TwilioSettingsPayload>
/**
 * Model AiSettings
 * 
 */
export type AiSettings = $Result.DefaultSelection<Prisma.$AiSettingsPayload>
/**
 * Model OfficeHours
 * 
 */
export type OfficeHours = $Result.DefaultSelection<Prisma.$OfficeHoursPayload>
/**
 * Model OfficeContact
 * 
 */
export type OfficeContact = $Result.DefaultSelection<Prisma.$OfficeContactPayload>
/**
 * Model InsuranceContact
 * 
 */
export type InsuranceContact = $Result.DefaultSelection<Prisma.$InsuranceContactPayload>
/**
 * Model ProcedureTimeslot
 * 
 */
export type ProcedureTimeslot = $Result.DefaultSelection<Prisma.$ProcedureTimeslotPayload>
/**
 * Model PatientConversation
 * 
 */
export type PatientConversation = $Result.DefaultSelection<Prisma.$PatientConversationPayload>
/**
 * Model CommissionBatch
 * 
 */
export type CommissionBatch = $Result.DefaultSelection<Prisma.$CommissionBatchPayload>
/**
 * Model CommissionBatchItem
 * 
 */
export type CommissionBatchItem = $Result.DefaultSelection<Prisma.$CommissionBatchItemPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const PatientStatus: {
  ACTIVE: 'ACTIVE',
  INACTIVE: 'INACTIVE',
  UNKNOWN: 'UNKNOWN',
  PLAN_NOT_ACCEPTED: 'PLAN_NOT_ACCEPTED'
};

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


export const ProcedureSource: {
  COMBO: 'COMBO',
  MANUAL: 'MANUAL'
};

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


export const ClaimStatus: {
  PENDING: 'PENDING',
  APPROVED: 'APPROVED',
  CANCELLED: 'CANCELLED',
  REVIEW: 'REVIEW',
  VOID: 'VOID',
  PREAUTH: 'PREAUTH'
};

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


export const MissingTeethStatus: {
  No_missing: 'No_missing',
  endentulous: 'endentulous',
  Yes_missing: 'Yes_missing'
};

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


export const ServiceLineStatus: {
  PENDING: 'PENDING',
  PARTIALLY_PAID: 'PARTIALLY_PAID',
  PAID: 'PAID',
  UNPAID: 'UNPAID',
  ADJUSTED: 'ADJUSTED',
  OVERPAID: 'OVERPAID',
  DENIED: 'DENIED'
};

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


export const PdfTitleKey: {
  INSURANCE_CLAIM: 'INSURANCE_CLAIM',
  INSURANCE_CLAIM_PREAUTH: 'INSURANCE_CLAIM_PREAUTH',
  ELIGIBILITY_STATUS: 'ELIGIBILITY_STATUS',
  CLAIM_STATUS: 'CLAIM_STATUS',
  OTHER: 'OTHER'
};

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


export const PaymentStatus: {
  PENDING: 'PENDING',
  PARTIALLY_PAID: 'PARTIALLY_PAID',
  PAID: 'PAID',
  OVERPAID: 'OVERPAID',
  DENIED: 'DENIED',
  VOID: 'VOID'
};

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


export const PaymentMethod: {
  EFT: 'EFT',
  CHECK: 'CHECK',
  CASH: 'CASH',
  CARD: 'CARD',
  OTHER: 'OTHER'
};

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


export const NotificationTypes: {
  BACKUP: 'BACKUP',
  CLAIM: 'CLAIM',
  PAYMENT: 'PAYMENT',
  ETC: 'ETC'
};

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


export const CommunicationChannel: {
  sms: 'sms',
  voice: 'voice'
};

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


export const CommunicationDirection: {
  outbound: 'outbound',
  inbound: 'inbound'
};

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


export const CommunicationStatus: {
  queued: 'queued',
  sent: 'sent',
  delivered: 'delivered',
  failed: 'failed',
  completed: 'completed',
  busy: 'busy',
  no_answer: 'no_answer'
};

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

}

export type PatientStatus = $Enums.PatientStatus

export const PatientStatus: typeof $Enums.PatientStatus

export type ProcedureSource = $Enums.ProcedureSource

export const ProcedureSource: typeof $Enums.ProcedureSource

export type ClaimStatus = $Enums.ClaimStatus

export const ClaimStatus: typeof $Enums.ClaimStatus

export type MissingTeethStatus = $Enums.MissingTeethStatus

export const MissingTeethStatus: typeof $Enums.MissingTeethStatus

export type ServiceLineStatus = $Enums.ServiceLineStatus

export const ServiceLineStatus: typeof $Enums.ServiceLineStatus

export type PdfTitleKey = $Enums.PdfTitleKey

export const PdfTitleKey: typeof $Enums.PdfTitleKey

export type PaymentStatus = $Enums.PaymentStatus

export const PaymentStatus: typeof $Enums.PaymentStatus

export type PaymentMethod = $Enums.PaymentMethod

export const PaymentMethod: typeof $Enums.PaymentMethod

export type NotificationTypes = $Enums.NotificationTypes

export const NotificationTypes: typeof $Enums.NotificationTypes

export type CommunicationChannel = $Enums.CommunicationChannel

export const CommunicationChannel: typeof $Enums.CommunicationChannel

export type CommunicationDirection = $Enums.CommunicationDirection

export const CommunicationDirection: typeof $Enums.CommunicationDirection

export type CommunicationStatus = $Enums.CommunicationStatus

export const CommunicationStatus: typeof $Enums.CommunicationStatus

/**
 * ##  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://pris.ly/d/client).
 */
export class PrismaClient<
  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  const 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://pris.ly/d/client).
   */

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

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

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

/**
   * 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://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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/orm/prisma-client/queries/transactions).
   */
  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>

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

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

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

  /**
   * `prisma.patient`: Exposes CRUD operations for the **Patient** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Patients
    * const patients = await prisma.patient.findMany()
    * ```
    */
  get patient(): Prisma.PatientDelegate<ExtArgs, ClientOptions>;

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

  /**
   * `prisma.appointmentFile`: Exposes CRUD operations for the **AppointmentFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppointmentFiles
    * const appointmentFiles = await prisma.appointmentFile.findMany()
    * ```
    */
  get appointmentFile(): Prisma.AppointmentFileDelegate<ExtArgs, ClientOptions>;

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

  /**
   * `prisma.npiProvider`: Exposes CRUD operations for the **NpiProvider** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more NpiProviders
    * const npiProviders = await prisma.npiProvider.findMany()
    * ```
    */
  get npiProvider(): Prisma.NpiProviderDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.appointmentProcedure`: Exposes CRUD operations for the **AppointmentProcedure** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppointmentProcedures
    * const appointmentProcedures = await prisma.appointmentProcedure.findMany()
    * ```
    */
  get appointmentProcedure(): Prisma.AppointmentProcedureDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.claim`: Exposes CRUD operations for the **Claim** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Claims
    * const claims = await prisma.claim.findMany()
    * ```
    */
  get claim(): Prisma.ClaimDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.serviceLine`: Exposes CRUD operations for the **ServiceLine** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ServiceLines
    * const serviceLines = await prisma.serviceLine.findMany()
    * ```
    */
  get serviceLine(): Prisma.ServiceLineDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.claimFile`: Exposes CRUD operations for the **ClaimFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ClaimFiles
    * const claimFiles = await prisma.claimFile.findMany()
    * ```
    */
  get claimFile(): Prisma.ClaimFileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.insuranceCredential`: Exposes CRUD operations for the **InsuranceCredential** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more InsuranceCredentials
    * const insuranceCredentials = await prisma.insuranceCredential.findMany()
    * ```
    */
  get insuranceCredential(): Prisma.InsuranceCredentialDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.shoppingVendor`: Exposes CRUD operations for the **ShoppingVendor** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ShoppingVendors
    * const shoppingVendors = await prisma.shoppingVendor.findMany()
    * ```
    */
  get shoppingVendor(): Prisma.ShoppingVendorDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.pdfGroup`: Exposes CRUD operations for the **PdfGroup** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PdfGroups
    * const pdfGroups = await prisma.pdfGroup.findMany()
    * ```
    */
  get pdfGroup(): Prisma.PdfGroupDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.pdfFile`: Exposes CRUD operations for the **PdfFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PdfFiles
    * const pdfFiles = await prisma.pdfFile.findMany()
    * ```
    */
  get pdfFile(): Prisma.PdfFileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.payment`: Exposes CRUD operations for the **Payment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Payments
    * const payments = await prisma.payment.findMany()
    * ```
    */
  get payment(): Prisma.PaymentDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.serviceLineTransaction`: Exposes CRUD operations for the **ServiceLineTransaction** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ServiceLineTransactions
    * const serviceLineTransactions = await prisma.serviceLineTransaction.findMany()
    * ```
    */
  get serviceLineTransaction(): Prisma.ServiceLineTransactionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.databaseBackup`: Exposes CRUD operations for the **DatabaseBackup** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more DatabaseBackups
    * const databaseBackups = await prisma.databaseBackup.findMany()
    * ```
    */
  get databaseBackup(): Prisma.DatabaseBackupDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.backupDestination`: Exposes CRUD operations for the **BackupDestination** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more BackupDestinations
    * const backupDestinations = await prisma.backupDestination.findMany()
    * ```
    */
  get backupDestination(): Prisma.BackupDestinationDelegate<ExtArgs, ClientOptions>;

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

  /**
   * `prisma.cronJobLog`: Exposes CRUD operations for the **CronJobLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CronJobLogs
    * const cronJobLogs = await prisma.cronJobLog.findMany()
    * ```
    */
  get cronJobLog(): Prisma.CronJobLogDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.cloudFolder`: Exposes CRUD operations for the **CloudFolder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CloudFolders
    * const cloudFolders = await prisma.cloudFolder.findMany()
    * ```
    */
  get cloudFolder(): Prisma.CloudFolderDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.cloudFile`: Exposes CRUD operations for the **CloudFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CloudFiles
    * const cloudFiles = await prisma.cloudFile.findMany()
    * ```
    */
  get cloudFile(): Prisma.CloudFileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.cloudFileChunk`: Exposes CRUD operations for the **CloudFileChunk** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CloudFileChunks
    * const cloudFileChunks = await prisma.cloudFileChunk.findMany()
    * ```
    */
  get cloudFileChunk(): Prisma.CloudFileChunkDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.communication`: Exposes CRUD operations for the **Communication** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Communications
    * const communications = await prisma.communication.findMany()
    * ```
    */
  get communication(): Prisma.CommunicationDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.patientDocument`: Exposes CRUD operations for the **PatientDocument** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PatientDocuments
    * const patientDocuments = await prisma.patientDocument.findMany()
    * ```
    */
  get patientDocument(): Prisma.PatientDocumentDelegate<ExtArgs, ClientOptions>;

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

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

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

  /**
   * `prisma.officeContact`: Exposes CRUD operations for the **OfficeContact** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more OfficeContacts
    * const officeContacts = await prisma.officeContact.findMany()
    * ```
    */
  get officeContact(): Prisma.OfficeContactDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.insuranceContact`: Exposes CRUD operations for the **InsuranceContact** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more InsuranceContacts
    * const insuranceContacts = await prisma.insuranceContact.findMany()
    * ```
    */
  get insuranceContact(): Prisma.InsuranceContactDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.procedureTimeslot`: Exposes CRUD operations for the **ProcedureTimeslot** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProcedureTimeslots
    * const procedureTimeslots = await prisma.procedureTimeslot.findMany()
    * ```
    */
  get procedureTimeslot(): Prisma.ProcedureTimeslotDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.patientConversation`: Exposes CRUD operations for the **PatientConversation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PatientConversations
    * const patientConversations = await prisma.patientConversation.findMany()
    * ```
    */
  get patientConversation(): Prisma.PatientConversationDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.commissionBatch`: Exposes CRUD operations for the **CommissionBatch** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CommissionBatches
    * const commissionBatches = await prisma.commissionBatch.findMany()
    * ```
    */
  get commissionBatch(): Prisma.CommissionBatchDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.commissionBatchItem`: Exposes CRUD operations for the **CommissionBatchItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CommissionBatchItems
    * const commissionBatchItems = await prisma.commissionBatchItem.findMany()
    * ```
    */
  get commissionBatchItem(): Prisma.CommissionBatchItemDelegate<ExtArgs, ClientOptions>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
  * 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: 7.4.1
   * Query Engine version: 55ae170b1ced7fc6ed07a15f110549408c501bb3
   */
  export type PrismaVersion = {
    client: string
    engine: string
  }

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };

  /**
   * XOR is needed to have a real mutually exclusive union type
   * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
   */
  type XOR<T, U> =
    T extends object ?
    U extends object ?
      (Without<T, U> & U) | (Without<U, T> & T)
    : U : T


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

  /**
   * Like `Pick`, but additionally can also accept an array of keys
   */
  type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>

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


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

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


  export const ModelName: {
    User: 'User',
    Patient: 'Patient',
    Appointment: 'Appointment',
    AppointmentFile: 'AppointmentFile',
    Staff: 'Staff',
    NpiProvider: 'NpiProvider',
    AppointmentProcedure: 'AppointmentProcedure',
    Claim: 'Claim',
    ServiceLine: 'ServiceLine',
    ClaimFile: 'ClaimFile',
    InsuranceCredential: 'InsuranceCredential',
    ShoppingVendor: 'ShoppingVendor',
    PdfGroup: 'PdfGroup',
    PdfFile: 'PdfFile',
    Payment: 'Payment',
    ServiceLineTransaction: 'ServiceLineTransaction',
    DatabaseBackup: 'DatabaseBackup',
    BackupDestination: 'BackupDestination',
    Notification: 'Notification',
    CronJobLog: 'CronJobLog',
    CloudFolder: 'CloudFolder',
    CloudFile: 'CloudFile',
    CloudFileChunk: 'CloudFileChunk',
    Communication: 'Communication',
    PatientDocument: 'PatientDocument',
    TwilioSettings: 'TwilioSettings',
    AiSettings: 'AiSettings',
    OfficeHours: 'OfficeHours',
    OfficeContact: 'OfficeContact',
    InsuranceContact: 'InsuranceContact',
    ProcedureTimeslot: 'ProcedureTimeslot',
    PatientConversation: 'PatientConversation',
    CommissionBatch: 'CommissionBatch',
    CommissionBatchItem: 'CommissionBatchItem'
  };

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



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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "user" | "patient" | "appointment" | "appointmentFile" | "staff" | "npiProvider" | "appointmentProcedure" | "claim" | "serviceLine" | "claimFile" | "insuranceCredential" | "shoppingVendor" | "pdfGroup" | "pdfFile" | "payment" | "serviceLineTransaction" | "databaseBackup" | "backupDestination" | "notification" | "cronJobLog" | "cloudFolder" | "cloudFile" | "cloudFileChunk" | "communication" | "patientDocument" | "twilioSettings" | "aiSettings" | "officeHours" | "officeContact" | "insuranceContact" | "procedureTimeslot" | "patientConversation" | "commissionBatch" | "commissionBatchItem"
      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
          }
          updateManyAndReturn: {
            args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          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
          }
        }
      }
      Patient: {
        payload: Prisma.$PatientPayload<ExtArgs>
        fields: Prisma.PatientFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PatientFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PatientFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          findFirst: {
            args: Prisma.PatientFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PatientFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          findMany: {
            args: Prisma.PatientFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>[]
          }
          create: {
            args: Prisma.PatientCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          createMany: {
            args: Prisma.PatientCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PatientCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>[]
          }
          delete: {
            args: Prisma.PatientDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          update: {
            args: Prisma.PatientUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          deleteMany: {
            args: Prisma.PatientDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PatientUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PatientUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>[]
          }
          upsert: {
            args: Prisma.PatientUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientPayload>
          }
          aggregate: {
            args: Prisma.PatientAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePatient>
          }
          groupBy: {
            args: Prisma.PatientGroupByArgs<ExtArgs>
            result: $Utils.Optional<PatientGroupByOutputType>[]
          }
          count: {
            args: Prisma.PatientCountArgs<ExtArgs>
            result: $Utils.Optional<PatientCountAggregateOutputType> | 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
          }
          updateManyAndReturn: {
            args: Prisma.AppointmentUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>[]
          }
          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
          }
        }
      }
      AppointmentFile: {
        payload: Prisma.$AppointmentFilePayload<ExtArgs>
        fields: Prisma.AppointmentFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          findFirst: {
            args: Prisma.AppointmentFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          findMany: {
            args: Prisma.AppointmentFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>[]
          }
          create: {
            args: Prisma.AppointmentFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          createMany: {
            args: Prisma.AppointmentFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AppointmentFileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>[]
          }
          delete: {
            args: Prisma.AppointmentFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          update: {
            args: Prisma.AppointmentFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          deleteMany: {
            args: Prisma.AppointmentFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AppointmentFileUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>[]
          }
          upsert: {
            args: Prisma.AppointmentFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentFilePayload>
          }
          aggregate: {
            args: Prisma.AppointmentFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAppointmentFile>
          }
          groupBy: {
            args: Prisma.AppointmentFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<AppointmentFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentFileCountArgs<ExtArgs>
            result: $Utils.Optional<AppointmentFileCountAggregateOutputType> | number
          }
        }
      }
      Staff: {
        payload: Prisma.$StaffPayload<ExtArgs>
        fields: Prisma.StaffFieldRefs
        operations: {
          findUnique: {
            args: Prisma.StaffFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.StaffFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          findFirst: {
            args: Prisma.StaffFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.StaffFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          findMany: {
            args: Prisma.StaffFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>[]
          }
          create: {
            args: Prisma.StaffCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          createMany: {
            args: Prisma.StaffCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.StaffCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>[]
          }
          delete: {
            args: Prisma.StaffDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          update: {
            args: Prisma.StaffUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          deleteMany: {
            args: Prisma.StaffDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.StaffUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.StaffUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>[]
          }
          upsert: {
            args: Prisma.StaffUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$StaffPayload>
          }
          aggregate: {
            args: Prisma.StaffAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateStaff>
          }
          groupBy: {
            args: Prisma.StaffGroupByArgs<ExtArgs>
            result: $Utils.Optional<StaffGroupByOutputType>[]
          }
          count: {
            args: Prisma.StaffCountArgs<ExtArgs>
            result: $Utils.Optional<StaffCountAggregateOutputType> | number
          }
        }
      }
      NpiProvider: {
        payload: Prisma.$NpiProviderPayload<ExtArgs>
        fields: Prisma.NpiProviderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NpiProviderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NpiProviderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          findFirst: {
            args: Prisma.NpiProviderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NpiProviderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          findMany: {
            args: Prisma.NpiProviderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>[]
          }
          create: {
            args: Prisma.NpiProviderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          createMany: {
            args: Prisma.NpiProviderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.NpiProviderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>[]
          }
          delete: {
            args: Prisma.NpiProviderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          update: {
            args: Prisma.NpiProviderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          deleteMany: {
            args: Prisma.NpiProviderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NpiProviderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.NpiProviderUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>[]
          }
          upsert: {
            args: Prisma.NpiProviderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NpiProviderPayload>
          }
          aggregate: {
            args: Prisma.NpiProviderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNpiProvider>
          }
          groupBy: {
            args: Prisma.NpiProviderGroupByArgs<ExtArgs>
            result: $Utils.Optional<NpiProviderGroupByOutputType>[]
          }
          count: {
            args: Prisma.NpiProviderCountArgs<ExtArgs>
            result: $Utils.Optional<NpiProviderCountAggregateOutputType> | number
          }
        }
      }
      AppointmentProcedure: {
        payload: Prisma.$AppointmentProcedurePayload<ExtArgs>
        fields: Prisma.AppointmentProcedureFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentProcedureFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentProcedureFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          findFirst: {
            args: Prisma.AppointmentProcedureFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentProcedureFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          findMany: {
            args: Prisma.AppointmentProcedureFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>[]
          }
          create: {
            args: Prisma.AppointmentProcedureCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          createMany: {
            args: Prisma.AppointmentProcedureCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AppointmentProcedureCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>[]
          }
          delete: {
            args: Prisma.AppointmentProcedureDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          update: {
            args: Prisma.AppointmentProcedureUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          deleteMany: {
            args: Prisma.AppointmentProcedureDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentProcedureUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AppointmentProcedureUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>[]
          }
          upsert: {
            args: Prisma.AppointmentProcedureUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentProcedurePayload>
          }
          aggregate: {
            args: Prisma.AppointmentProcedureAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAppointmentProcedure>
          }
          groupBy: {
            args: Prisma.AppointmentProcedureGroupByArgs<ExtArgs>
            result: $Utils.Optional<AppointmentProcedureGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentProcedureCountArgs<ExtArgs>
            result: $Utils.Optional<AppointmentProcedureCountAggregateOutputType> | number
          }
        }
      }
      Claim: {
        payload: Prisma.$ClaimPayload<ExtArgs>
        fields: Prisma.ClaimFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ClaimFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ClaimFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          findFirst: {
            args: Prisma.ClaimFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ClaimFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          findMany: {
            args: Prisma.ClaimFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
          }
          create: {
            args: Prisma.ClaimCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          createMany: {
            args: Prisma.ClaimCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ClaimCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
          }
          delete: {
            args: Prisma.ClaimDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          update: {
            args: Prisma.ClaimUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          deleteMany: {
            args: Prisma.ClaimDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ClaimUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ClaimUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
          }
          upsert: {
            args: Prisma.ClaimUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
          }
          aggregate: {
            args: Prisma.ClaimAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClaim>
          }
          groupBy: {
            args: Prisma.ClaimGroupByArgs<ExtArgs>
            result: $Utils.Optional<ClaimGroupByOutputType>[]
          }
          count: {
            args: Prisma.ClaimCountArgs<ExtArgs>
            result: $Utils.Optional<ClaimCountAggregateOutputType> | number
          }
        }
      }
      ServiceLine: {
        payload: Prisma.$ServiceLinePayload<ExtArgs>
        fields: Prisma.ServiceLineFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ServiceLineFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ServiceLineFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          findFirst: {
            args: Prisma.ServiceLineFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ServiceLineFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          findMany: {
            args: Prisma.ServiceLineFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>[]
          }
          create: {
            args: Prisma.ServiceLineCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          createMany: {
            args: Prisma.ServiceLineCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ServiceLineCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>[]
          }
          delete: {
            args: Prisma.ServiceLineDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          update: {
            args: Prisma.ServiceLineUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          deleteMany: {
            args: Prisma.ServiceLineDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ServiceLineUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ServiceLineUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>[]
          }
          upsert: {
            args: Prisma.ServiceLineUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLinePayload>
          }
          aggregate: {
            args: Prisma.ServiceLineAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateServiceLine>
          }
          groupBy: {
            args: Prisma.ServiceLineGroupByArgs<ExtArgs>
            result: $Utils.Optional<ServiceLineGroupByOutputType>[]
          }
          count: {
            args: Prisma.ServiceLineCountArgs<ExtArgs>
            result: $Utils.Optional<ServiceLineCountAggregateOutputType> | number
          }
        }
      }
      ClaimFile: {
        payload: Prisma.$ClaimFilePayload<ExtArgs>
        fields: Prisma.ClaimFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ClaimFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ClaimFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          findFirst: {
            args: Prisma.ClaimFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ClaimFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          findMany: {
            args: Prisma.ClaimFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>[]
          }
          create: {
            args: Prisma.ClaimFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          createMany: {
            args: Prisma.ClaimFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ClaimFileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>[]
          }
          delete: {
            args: Prisma.ClaimFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          update: {
            args: Prisma.ClaimFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          deleteMany: {
            args: Prisma.ClaimFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ClaimFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ClaimFileUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>[]
          }
          upsert: {
            args: Prisma.ClaimFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ClaimFilePayload>
          }
          aggregate: {
            args: Prisma.ClaimFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClaimFile>
          }
          groupBy: {
            args: Prisma.ClaimFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<ClaimFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.ClaimFileCountArgs<ExtArgs>
            result: $Utils.Optional<ClaimFileCountAggregateOutputType> | number
          }
        }
      }
      InsuranceCredential: {
        payload: Prisma.$InsuranceCredentialPayload<ExtArgs>
        fields: Prisma.InsuranceCredentialFieldRefs
        operations: {
          findUnique: {
            args: Prisma.InsuranceCredentialFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.InsuranceCredentialFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          findFirst: {
            args: Prisma.InsuranceCredentialFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.InsuranceCredentialFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          findMany: {
            args: Prisma.InsuranceCredentialFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>[]
          }
          create: {
            args: Prisma.InsuranceCredentialCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          createMany: {
            args: Prisma.InsuranceCredentialCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.InsuranceCredentialCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>[]
          }
          delete: {
            args: Prisma.InsuranceCredentialDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          update: {
            args: Prisma.InsuranceCredentialUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          deleteMany: {
            args: Prisma.InsuranceCredentialDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.InsuranceCredentialUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.InsuranceCredentialUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>[]
          }
          upsert: {
            args: Prisma.InsuranceCredentialUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceCredentialPayload>
          }
          aggregate: {
            args: Prisma.InsuranceCredentialAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateInsuranceCredential>
          }
          groupBy: {
            args: Prisma.InsuranceCredentialGroupByArgs<ExtArgs>
            result: $Utils.Optional<InsuranceCredentialGroupByOutputType>[]
          }
          count: {
            args: Prisma.InsuranceCredentialCountArgs<ExtArgs>
            result: $Utils.Optional<InsuranceCredentialCountAggregateOutputType> | number
          }
        }
      }
      ShoppingVendor: {
        payload: Prisma.$ShoppingVendorPayload<ExtArgs>
        fields: Prisma.ShoppingVendorFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ShoppingVendorFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ShoppingVendorFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          findFirst: {
            args: Prisma.ShoppingVendorFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ShoppingVendorFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          findMany: {
            args: Prisma.ShoppingVendorFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>[]
          }
          create: {
            args: Prisma.ShoppingVendorCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          createMany: {
            args: Prisma.ShoppingVendorCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ShoppingVendorCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>[]
          }
          delete: {
            args: Prisma.ShoppingVendorDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          update: {
            args: Prisma.ShoppingVendorUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          deleteMany: {
            args: Prisma.ShoppingVendorDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ShoppingVendorUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ShoppingVendorUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>[]
          }
          upsert: {
            args: Prisma.ShoppingVendorUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ShoppingVendorPayload>
          }
          aggregate: {
            args: Prisma.ShoppingVendorAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateShoppingVendor>
          }
          groupBy: {
            args: Prisma.ShoppingVendorGroupByArgs<ExtArgs>
            result: $Utils.Optional<ShoppingVendorGroupByOutputType>[]
          }
          count: {
            args: Prisma.ShoppingVendorCountArgs<ExtArgs>
            result: $Utils.Optional<ShoppingVendorCountAggregateOutputType> | number
          }
        }
      }
      PdfGroup: {
        payload: Prisma.$PdfGroupPayload<ExtArgs>
        fields: Prisma.PdfGroupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PdfGroupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PdfGroupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          findFirst: {
            args: Prisma.PdfGroupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PdfGroupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          findMany: {
            args: Prisma.PdfGroupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>[]
          }
          create: {
            args: Prisma.PdfGroupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          createMany: {
            args: Prisma.PdfGroupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PdfGroupCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>[]
          }
          delete: {
            args: Prisma.PdfGroupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          update: {
            args: Prisma.PdfGroupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          deleteMany: {
            args: Prisma.PdfGroupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PdfGroupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PdfGroupUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>[]
          }
          upsert: {
            args: Prisma.PdfGroupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfGroupPayload>
          }
          aggregate: {
            args: Prisma.PdfGroupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePdfGroup>
          }
          groupBy: {
            args: Prisma.PdfGroupGroupByArgs<ExtArgs>
            result: $Utils.Optional<PdfGroupGroupByOutputType>[]
          }
          count: {
            args: Prisma.PdfGroupCountArgs<ExtArgs>
            result: $Utils.Optional<PdfGroupCountAggregateOutputType> | number
          }
        }
      }
      PdfFile: {
        payload: Prisma.$PdfFilePayload<ExtArgs>
        fields: Prisma.PdfFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PdfFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PdfFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          findFirst: {
            args: Prisma.PdfFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PdfFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          findMany: {
            args: Prisma.PdfFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>[]
          }
          create: {
            args: Prisma.PdfFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          createMany: {
            args: Prisma.PdfFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PdfFileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>[]
          }
          delete: {
            args: Prisma.PdfFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          update: {
            args: Prisma.PdfFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          deleteMany: {
            args: Prisma.PdfFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PdfFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PdfFileUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>[]
          }
          upsert: {
            args: Prisma.PdfFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PdfFilePayload>
          }
          aggregate: {
            args: Prisma.PdfFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePdfFile>
          }
          groupBy: {
            args: Prisma.PdfFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<PdfFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.PdfFileCountArgs<ExtArgs>
            result: $Utils.Optional<PdfFileCountAggregateOutputType> | number
          }
        }
      }
      Payment: {
        payload: Prisma.$PaymentPayload<ExtArgs>
        fields: Prisma.PaymentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PaymentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PaymentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          findFirst: {
            args: Prisma.PaymentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PaymentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          findMany: {
            args: Prisma.PaymentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          create: {
            args: Prisma.PaymentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          createMany: {
            args: Prisma.PaymentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PaymentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          delete: {
            args: Prisma.PaymentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          update: {
            args: Prisma.PaymentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          deleteMany: {
            args: Prisma.PaymentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PaymentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PaymentUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          upsert: {
            args: Prisma.PaymentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          aggregate: {
            args: Prisma.PaymentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePayment>
          }
          groupBy: {
            args: Prisma.PaymentGroupByArgs<ExtArgs>
            result: $Utils.Optional<PaymentGroupByOutputType>[]
          }
          count: {
            args: Prisma.PaymentCountArgs<ExtArgs>
            result: $Utils.Optional<PaymentCountAggregateOutputType> | number
          }
        }
      }
      ServiceLineTransaction: {
        payload: Prisma.$ServiceLineTransactionPayload<ExtArgs>
        fields: Prisma.ServiceLineTransactionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ServiceLineTransactionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ServiceLineTransactionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          findFirst: {
            args: Prisma.ServiceLineTransactionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ServiceLineTransactionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          findMany: {
            args: Prisma.ServiceLineTransactionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>[]
          }
          create: {
            args: Prisma.ServiceLineTransactionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          createMany: {
            args: Prisma.ServiceLineTransactionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ServiceLineTransactionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>[]
          }
          delete: {
            args: Prisma.ServiceLineTransactionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          update: {
            args: Prisma.ServiceLineTransactionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          deleteMany: {
            args: Prisma.ServiceLineTransactionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ServiceLineTransactionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ServiceLineTransactionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>[]
          }
          upsert: {
            args: Prisma.ServiceLineTransactionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ServiceLineTransactionPayload>
          }
          aggregate: {
            args: Prisma.ServiceLineTransactionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateServiceLineTransaction>
          }
          groupBy: {
            args: Prisma.ServiceLineTransactionGroupByArgs<ExtArgs>
            result: $Utils.Optional<ServiceLineTransactionGroupByOutputType>[]
          }
          count: {
            args: Prisma.ServiceLineTransactionCountArgs<ExtArgs>
            result: $Utils.Optional<ServiceLineTransactionCountAggregateOutputType> | number
          }
        }
      }
      DatabaseBackup: {
        payload: Prisma.$DatabaseBackupPayload<ExtArgs>
        fields: Prisma.DatabaseBackupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.DatabaseBackupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.DatabaseBackupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          findFirst: {
            args: Prisma.DatabaseBackupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.DatabaseBackupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          findMany: {
            args: Prisma.DatabaseBackupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>[]
          }
          create: {
            args: Prisma.DatabaseBackupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          createMany: {
            args: Prisma.DatabaseBackupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.DatabaseBackupCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>[]
          }
          delete: {
            args: Prisma.DatabaseBackupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          update: {
            args: Prisma.DatabaseBackupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          deleteMany: {
            args: Prisma.DatabaseBackupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.DatabaseBackupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.DatabaseBackupUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>[]
          }
          upsert: {
            args: Prisma.DatabaseBackupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DatabaseBackupPayload>
          }
          aggregate: {
            args: Prisma.DatabaseBackupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDatabaseBackup>
          }
          groupBy: {
            args: Prisma.DatabaseBackupGroupByArgs<ExtArgs>
            result: $Utils.Optional<DatabaseBackupGroupByOutputType>[]
          }
          count: {
            args: Prisma.DatabaseBackupCountArgs<ExtArgs>
            result: $Utils.Optional<DatabaseBackupCountAggregateOutputType> | number
          }
        }
      }
      BackupDestination: {
        payload: Prisma.$BackupDestinationPayload<ExtArgs>
        fields: Prisma.BackupDestinationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BackupDestinationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BackupDestinationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          findFirst: {
            args: Prisma.BackupDestinationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BackupDestinationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          findMany: {
            args: Prisma.BackupDestinationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>[]
          }
          create: {
            args: Prisma.BackupDestinationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          createMany: {
            args: Prisma.BackupDestinationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BackupDestinationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>[]
          }
          delete: {
            args: Prisma.BackupDestinationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          update: {
            args: Prisma.BackupDestinationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          deleteMany: {
            args: Prisma.BackupDestinationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BackupDestinationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.BackupDestinationUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>[]
          }
          upsert: {
            args: Prisma.BackupDestinationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BackupDestinationPayload>
          }
          aggregate: {
            args: Prisma.BackupDestinationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBackupDestination>
          }
          groupBy: {
            args: Prisma.BackupDestinationGroupByArgs<ExtArgs>
            result: $Utils.Optional<BackupDestinationGroupByOutputType>[]
          }
          count: {
            args: Prisma.BackupDestinationCountArgs<ExtArgs>
            result: $Utils.Optional<BackupDestinationCountAggregateOutputType> | number
          }
        }
      }
      Notification: {
        payload: Prisma.$NotificationPayload<ExtArgs>
        fields: Prisma.NotificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NotificationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NotificationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findFirst: {
            args: Prisma.NotificationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NotificationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findMany: {
            args: Prisma.NotificationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          create: {
            args: Prisma.NotificationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          createMany: {
            args: Prisma.NotificationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.NotificationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          delete: {
            args: Prisma.NotificationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          update: {
            args: Prisma.NotificationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          deleteMany: {
            args: Prisma.NotificationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NotificationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.NotificationUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          upsert: {
            args: Prisma.NotificationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          aggregate: {
            args: Prisma.NotificationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNotification>
          }
          groupBy: {
            args: Prisma.NotificationGroupByArgs<ExtArgs>
            result: $Utils.Optional<NotificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.NotificationCountArgs<ExtArgs>
            result: $Utils.Optional<NotificationCountAggregateOutputType> | number
          }
        }
      }
      CronJobLog: {
        payload: Prisma.$CronJobLogPayload<ExtArgs>
        fields: Prisma.CronJobLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CronJobLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CronJobLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          findFirst: {
            args: Prisma.CronJobLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CronJobLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          findMany: {
            args: Prisma.CronJobLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>[]
          }
          create: {
            args: Prisma.CronJobLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          createMany: {
            args: Prisma.CronJobLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CronJobLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>[]
          }
          delete: {
            args: Prisma.CronJobLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          update: {
            args: Prisma.CronJobLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          deleteMany: {
            args: Prisma.CronJobLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CronJobLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CronJobLogUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>[]
          }
          upsert: {
            args: Prisma.CronJobLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CronJobLogPayload>
          }
          aggregate: {
            args: Prisma.CronJobLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCronJobLog>
          }
          groupBy: {
            args: Prisma.CronJobLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<CronJobLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.CronJobLogCountArgs<ExtArgs>
            result: $Utils.Optional<CronJobLogCountAggregateOutputType> | number
          }
        }
      }
      CloudFolder: {
        payload: Prisma.$CloudFolderPayload<ExtArgs>
        fields: Prisma.CloudFolderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CloudFolderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CloudFolderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          findFirst: {
            args: Prisma.CloudFolderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CloudFolderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          findMany: {
            args: Prisma.CloudFolderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>[]
          }
          create: {
            args: Prisma.CloudFolderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          createMany: {
            args: Prisma.CloudFolderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CloudFolderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>[]
          }
          delete: {
            args: Prisma.CloudFolderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          update: {
            args: Prisma.CloudFolderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          deleteMany: {
            args: Prisma.CloudFolderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CloudFolderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CloudFolderUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>[]
          }
          upsert: {
            args: Prisma.CloudFolderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFolderPayload>
          }
          aggregate: {
            args: Prisma.CloudFolderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCloudFolder>
          }
          groupBy: {
            args: Prisma.CloudFolderGroupByArgs<ExtArgs>
            result: $Utils.Optional<CloudFolderGroupByOutputType>[]
          }
          count: {
            args: Prisma.CloudFolderCountArgs<ExtArgs>
            result: $Utils.Optional<CloudFolderCountAggregateOutputType> | number
          }
        }
      }
      CloudFile: {
        payload: Prisma.$CloudFilePayload<ExtArgs>
        fields: Prisma.CloudFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CloudFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CloudFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          findFirst: {
            args: Prisma.CloudFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CloudFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          findMany: {
            args: Prisma.CloudFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>[]
          }
          create: {
            args: Prisma.CloudFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          createMany: {
            args: Prisma.CloudFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CloudFileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>[]
          }
          delete: {
            args: Prisma.CloudFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          update: {
            args: Prisma.CloudFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          deleteMany: {
            args: Prisma.CloudFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CloudFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CloudFileUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>[]
          }
          upsert: {
            args: Prisma.CloudFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFilePayload>
          }
          aggregate: {
            args: Prisma.CloudFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCloudFile>
          }
          groupBy: {
            args: Prisma.CloudFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<CloudFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.CloudFileCountArgs<ExtArgs>
            result: $Utils.Optional<CloudFileCountAggregateOutputType> | number
          }
        }
      }
      CloudFileChunk: {
        payload: Prisma.$CloudFileChunkPayload<ExtArgs>
        fields: Prisma.CloudFileChunkFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CloudFileChunkFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CloudFileChunkFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          findFirst: {
            args: Prisma.CloudFileChunkFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CloudFileChunkFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          findMany: {
            args: Prisma.CloudFileChunkFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>[]
          }
          create: {
            args: Prisma.CloudFileChunkCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          createMany: {
            args: Prisma.CloudFileChunkCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CloudFileChunkCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>[]
          }
          delete: {
            args: Prisma.CloudFileChunkDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          update: {
            args: Prisma.CloudFileChunkUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          deleteMany: {
            args: Prisma.CloudFileChunkDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CloudFileChunkUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CloudFileChunkUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>[]
          }
          upsert: {
            args: Prisma.CloudFileChunkUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CloudFileChunkPayload>
          }
          aggregate: {
            args: Prisma.CloudFileChunkAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCloudFileChunk>
          }
          groupBy: {
            args: Prisma.CloudFileChunkGroupByArgs<ExtArgs>
            result: $Utils.Optional<CloudFileChunkGroupByOutputType>[]
          }
          count: {
            args: Prisma.CloudFileChunkCountArgs<ExtArgs>
            result: $Utils.Optional<CloudFileChunkCountAggregateOutputType> | number
          }
        }
      }
      Communication: {
        payload: Prisma.$CommunicationPayload<ExtArgs>
        fields: Prisma.CommunicationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommunicationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommunicationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          findFirst: {
            args: Prisma.CommunicationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommunicationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          findMany: {
            args: Prisma.CommunicationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>[]
          }
          create: {
            args: Prisma.CommunicationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          createMany: {
            args: Prisma.CommunicationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CommunicationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>[]
          }
          delete: {
            args: Prisma.CommunicationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          update: {
            args: Prisma.CommunicationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          deleteMany: {
            args: Prisma.CommunicationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommunicationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CommunicationUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>[]
          }
          upsert: {
            args: Prisma.CommunicationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommunicationPayload>
          }
          aggregate: {
            args: Prisma.CommunicationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCommunication>
          }
          groupBy: {
            args: Prisma.CommunicationGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommunicationGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommunicationCountArgs<ExtArgs>
            result: $Utils.Optional<CommunicationCountAggregateOutputType> | number
          }
        }
      }
      PatientDocument: {
        payload: Prisma.$PatientDocumentPayload<ExtArgs>
        fields: Prisma.PatientDocumentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PatientDocumentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PatientDocumentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          findFirst: {
            args: Prisma.PatientDocumentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PatientDocumentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          findMany: {
            args: Prisma.PatientDocumentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>[]
          }
          create: {
            args: Prisma.PatientDocumentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          createMany: {
            args: Prisma.PatientDocumentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PatientDocumentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>[]
          }
          delete: {
            args: Prisma.PatientDocumentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          update: {
            args: Prisma.PatientDocumentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          deleteMany: {
            args: Prisma.PatientDocumentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PatientDocumentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PatientDocumentUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>[]
          }
          upsert: {
            args: Prisma.PatientDocumentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientDocumentPayload>
          }
          aggregate: {
            args: Prisma.PatientDocumentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePatientDocument>
          }
          groupBy: {
            args: Prisma.PatientDocumentGroupByArgs<ExtArgs>
            result: $Utils.Optional<PatientDocumentGroupByOutputType>[]
          }
          count: {
            args: Prisma.PatientDocumentCountArgs<ExtArgs>
            result: $Utils.Optional<PatientDocumentCountAggregateOutputType> | number
          }
        }
      }
      TwilioSettings: {
        payload: Prisma.$TwilioSettingsPayload<ExtArgs>
        fields: Prisma.TwilioSettingsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TwilioSettingsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TwilioSettingsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          findFirst: {
            args: Prisma.TwilioSettingsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TwilioSettingsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          findMany: {
            args: Prisma.TwilioSettingsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>[]
          }
          create: {
            args: Prisma.TwilioSettingsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          createMany: {
            args: Prisma.TwilioSettingsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TwilioSettingsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>[]
          }
          delete: {
            args: Prisma.TwilioSettingsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          update: {
            args: Prisma.TwilioSettingsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          deleteMany: {
            args: Prisma.TwilioSettingsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TwilioSettingsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TwilioSettingsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>[]
          }
          upsert: {
            args: Prisma.TwilioSettingsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TwilioSettingsPayload>
          }
          aggregate: {
            args: Prisma.TwilioSettingsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTwilioSettings>
          }
          groupBy: {
            args: Prisma.TwilioSettingsGroupByArgs<ExtArgs>
            result: $Utils.Optional<TwilioSettingsGroupByOutputType>[]
          }
          count: {
            args: Prisma.TwilioSettingsCountArgs<ExtArgs>
            result: $Utils.Optional<TwilioSettingsCountAggregateOutputType> | number
          }
        }
      }
      AiSettings: {
        payload: Prisma.$AiSettingsPayload<ExtArgs>
        fields: Prisma.AiSettingsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AiSettingsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AiSettingsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          findFirst: {
            args: Prisma.AiSettingsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AiSettingsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          findMany: {
            args: Prisma.AiSettingsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>[]
          }
          create: {
            args: Prisma.AiSettingsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          createMany: {
            args: Prisma.AiSettingsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AiSettingsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>[]
          }
          delete: {
            args: Prisma.AiSettingsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          update: {
            args: Prisma.AiSettingsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          deleteMany: {
            args: Prisma.AiSettingsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AiSettingsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AiSettingsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>[]
          }
          upsert: {
            args: Prisma.AiSettingsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AiSettingsPayload>
          }
          aggregate: {
            args: Prisma.AiSettingsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAiSettings>
          }
          groupBy: {
            args: Prisma.AiSettingsGroupByArgs<ExtArgs>
            result: $Utils.Optional<AiSettingsGroupByOutputType>[]
          }
          count: {
            args: Prisma.AiSettingsCountArgs<ExtArgs>
            result: $Utils.Optional<AiSettingsCountAggregateOutputType> | number
          }
        }
      }
      OfficeHours: {
        payload: Prisma.$OfficeHoursPayload<ExtArgs>
        fields: Prisma.OfficeHoursFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OfficeHoursFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OfficeHoursFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          findFirst: {
            args: Prisma.OfficeHoursFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OfficeHoursFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          findMany: {
            args: Prisma.OfficeHoursFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>[]
          }
          create: {
            args: Prisma.OfficeHoursCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          createMany: {
            args: Prisma.OfficeHoursCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OfficeHoursCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>[]
          }
          delete: {
            args: Prisma.OfficeHoursDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          update: {
            args: Prisma.OfficeHoursUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          deleteMany: {
            args: Prisma.OfficeHoursDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OfficeHoursUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.OfficeHoursUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>[]
          }
          upsert: {
            args: Prisma.OfficeHoursUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeHoursPayload>
          }
          aggregate: {
            args: Prisma.OfficeHoursAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOfficeHours>
          }
          groupBy: {
            args: Prisma.OfficeHoursGroupByArgs<ExtArgs>
            result: $Utils.Optional<OfficeHoursGroupByOutputType>[]
          }
          count: {
            args: Prisma.OfficeHoursCountArgs<ExtArgs>
            result: $Utils.Optional<OfficeHoursCountAggregateOutputType> | number
          }
        }
      }
      OfficeContact: {
        payload: Prisma.$OfficeContactPayload<ExtArgs>
        fields: Prisma.OfficeContactFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OfficeContactFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OfficeContactFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          findFirst: {
            args: Prisma.OfficeContactFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OfficeContactFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          findMany: {
            args: Prisma.OfficeContactFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>[]
          }
          create: {
            args: Prisma.OfficeContactCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          createMany: {
            args: Prisma.OfficeContactCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OfficeContactCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>[]
          }
          delete: {
            args: Prisma.OfficeContactDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          update: {
            args: Prisma.OfficeContactUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          deleteMany: {
            args: Prisma.OfficeContactDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OfficeContactUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.OfficeContactUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>[]
          }
          upsert: {
            args: Prisma.OfficeContactUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OfficeContactPayload>
          }
          aggregate: {
            args: Prisma.OfficeContactAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOfficeContact>
          }
          groupBy: {
            args: Prisma.OfficeContactGroupByArgs<ExtArgs>
            result: $Utils.Optional<OfficeContactGroupByOutputType>[]
          }
          count: {
            args: Prisma.OfficeContactCountArgs<ExtArgs>
            result: $Utils.Optional<OfficeContactCountAggregateOutputType> | number
          }
        }
      }
      InsuranceContact: {
        payload: Prisma.$InsuranceContactPayload<ExtArgs>
        fields: Prisma.InsuranceContactFieldRefs
        operations: {
          findUnique: {
            args: Prisma.InsuranceContactFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.InsuranceContactFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          findFirst: {
            args: Prisma.InsuranceContactFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.InsuranceContactFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          findMany: {
            args: Prisma.InsuranceContactFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>[]
          }
          create: {
            args: Prisma.InsuranceContactCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          createMany: {
            args: Prisma.InsuranceContactCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.InsuranceContactCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>[]
          }
          delete: {
            args: Prisma.InsuranceContactDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          update: {
            args: Prisma.InsuranceContactUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          deleteMany: {
            args: Prisma.InsuranceContactDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.InsuranceContactUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.InsuranceContactUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>[]
          }
          upsert: {
            args: Prisma.InsuranceContactUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InsuranceContactPayload>
          }
          aggregate: {
            args: Prisma.InsuranceContactAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateInsuranceContact>
          }
          groupBy: {
            args: Prisma.InsuranceContactGroupByArgs<ExtArgs>
            result: $Utils.Optional<InsuranceContactGroupByOutputType>[]
          }
          count: {
            args: Prisma.InsuranceContactCountArgs<ExtArgs>
            result: $Utils.Optional<InsuranceContactCountAggregateOutputType> | number
          }
        }
      }
      ProcedureTimeslot: {
        payload: Prisma.$ProcedureTimeslotPayload<ExtArgs>
        fields: Prisma.ProcedureTimeslotFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProcedureTimeslotFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProcedureTimeslotFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          findFirst: {
            args: Prisma.ProcedureTimeslotFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProcedureTimeslotFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          findMany: {
            args: Prisma.ProcedureTimeslotFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>[]
          }
          create: {
            args: Prisma.ProcedureTimeslotCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          createMany: {
            args: Prisma.ProcedureTimeslotCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ProcedureTimeslotCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>[]
          }
          delete: {
            args: Prisma.ProcedureTimeslotDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          update: {
            args: Prisma.ProcedureTimeslotUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          deleteMany: {
            args: Prisma.ProcedureTimeslotDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProcedureTimeslotUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ProcedureTimeslotUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>[]
          }
          upsert: {
            args: Prisma.ProcedureTimeslotUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProcedureTimeslotPayload>
          }
          aggregate: {
            args: Prisma.ProcedureTimeslotAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProcedureTimeslot>
          }
          groupBy: {
            args: Prisma.ProcedureTimeslotGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProcedureTimeslotGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProcedureTimeslotCountArgs<ExtArgs>
            result: $Utils.Optional<ProcedureTimeslotCountAggregateOutputType> | number
          }
        }
      }
      PatientConversation: {
        payload: Prisma.$PatientConversationPayload<ExtArgs>
        fields: Prisma.PatientConversationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PatientConversationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PatientConversationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          findFirst: {
            args: Prisma.PatientConversationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PatientConversationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          findMany: {
            args: Prisma.PatientConversationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>[]
          }
          create: {
            args: Prisma.PatientConversationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          createMany: {
            args: Prisma.PatientConversationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PatientConversationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>[]
          }
          delete: {
            args: Prisma.PatientConversationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          update: {
            args: Prisma.PatientConversationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          deleteMany: {
            args: Prisma.PatientConversationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PatientConversationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PatientConversationUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>[]
          }
          upsert: {
            args: Prisma.PatientConversationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PatientConversationPayload>
          }
          aggregate: {
            args: Prisma.PatientConversationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePatientConversation>
          }
          groupBy: {
            args: Prisma.PatientConversationGroupByArgs<ExtArgs>
            result: $Utils.Optional<PatientConversationGroupByOutputType>[]
          }
          count: {
            args: Prisma.PatientConversationCountArgs<ExtArgs>
            result: $Utils.Optional<PatientConversationCountAggregateOutputType> | number
          }
        }
      }
      CommissionBatch: {
        payload: Prisma.$CommissionBatchPayload<ExtArgs>
        fields: Prisma.CommissionBatchFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommissionBatchFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommissionBatchFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          findFirst: {
            args: Prisma.CommissionBatchFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommissionBatchFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          findMany: {
            args: Prisma.CommissionBatchFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>[]
          }
          create: {
            args: Prisma.CommissionBatchCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          createMany: {
            args: Prisma.CommissionBatchCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CommissionBatchCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>[]
          }
          delete: {
            args: Prisma.CommissionBatchDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          update: {
            args: Prisma.CommissionBatchUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          deleteMany: {
            args: Prisma.CommissionBatchDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommissionBatchUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CommissionBatchUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>[]
          }
          upsert: {
            args: Prisma.CommissionBatchUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchPayload>
          }
          aggregate: {
            args: Prisma.CommissionBatchAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCommissionBatch>
          }
          groupBy: {
            args: Prisma.CommissionBatchGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommissionBatchGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommissionBatchCountArgs<ExtArgs>
            result: $Utils.Optional<CommissionBatchCountAggregateOutputType> | number
          }
        }
      }
      CommissionBatchItem: {
        payload: Prisma.$CommissionBatchItemPayload<ExtArgs>
        fields: Prisma.CommissionBatchItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommissionBatchItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommissionBatchItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          findFirst: {
            args: Prisma.CommissionBatchItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommissionBatchItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          findMany: {
            args: Prisma.CommissionBatchItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>[]
          }
          create: {
            args: Prisma.CommissionBatchItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          createMany: {
            args: Prisma.CommissionBatchItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CommissionBatchItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>[]
          }
          delete: {
            args: Prisma.CommissionBatchItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          update: {
            args: Prisma.CommissionBatchItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          deleteMany: {
            args: Prisma.CommissionBatchItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommissionBatchItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CommissionBatchItemUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>[]
          }
          upsert: {
            args: Prisma.CommissionBatchItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommissionBatchItemPayload>
          }
          aggregate: {
            args: Prisma.CommissionBatchItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCommissionBatchItem>
          }
          groupBy: {
            args: Prisma.CommissionBatchItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommissionBatchItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommissionBatchItemCountArgs<ExtArgs>
            result: $Utils.Optional<CommissionBatchItemCountAggregateOutputType> | 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 {
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Shorthand for `emit: 'stdout'`
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events only
     * log: [
     *   { emit: 'event', level: 'query' },
     *   { emit: 'event', level: 'info' },
     *   { emit: 'event', level: 'warn' }
     *   { emit: 'event', level: 'error' }
     * ]
     * 
     * / Emit as events and log to stdout
     * og: [
     *  { emit: 'stdout', level: 'query' },
     *  { emit: 'stdout', level: 'info' },
     *  { emit: 'stdout', level: 'warn' }
     *  { emit: 'stdout', level: 'error' }
     * 
     * ```
     * Read more in our [docs](https://pris.ly/d/logging).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
    /**
     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
     */
    adapter?: runtime.SqlDriverAdapterFactory
    /**
     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
     */
    accelerateUrl?: string
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
    /**
     * SQL commenter plugins that add metadata to SQL queries as comments.
     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   adapter,
     *   comments: [
     *     traceContext(),
     *     queryInsights(),
     *   ],
     * })
     * ```
     */
    comments?: runtime.SqlCommenterPlugin[]
  }
  export type GlobalOmitConfig = {
    user?: UserOmit
    patient?: PatientOmit
    appointment?: AppointmentOmit
    appointmentFile?: AppointmentFileOmit
    staff?: StaffOmit
    npiProvider?: NpiProviderOmit
    appointmentProcedure?: AppointmentProcedureOmit
    claim?: ClaimOmit
    serviceLine?: ServiceLineOmit
    claimFile?: ClaimFileOmit
    insuranceCredential?: InsuranceCredentialOmit
    shoppingVendor?: ShoppingVendorOmit
    pdfGroup?: PdfGroupOmit
    pdfFile?: PdfFileOmit
    payment?: PaymentOmit
    serviceLineTransaction?: ServiceLineTransactionOmit
    databaseBackup?: DatabaseBackupOmit
    backupDestination?: BackupDestinationOmit
    notification?: NotificationOmit
    cronJobLog?: CronJobLogOmit
    cloudFolder?: CloudFolderOmit
    cloudFile?: CloudFileOmit
    cloudFileChunk?: CloudFileChunkOmit
    communication?: CommunicationOmit
    patientDocument?: PatientDocumentOmit
    twilioSettings?: TwilioSettingsOmit
    aiSettings?: AiSettingsOmit
    officeHours?: OfficeHoursOmit
    officeContact?: OfficeContactOmit
    insuranceContact?: InsuranceContactOmit
    procedureTimeslot?: ProcedureTimeslotOmit
    patientConversation?: PatientConversationOmit
    commissionBatch?: CommissionBatchOmit
    commissionBatchItem?: CommissionBatchItemOmit
  }

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

  export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;

  export type GetLogType<T> = CheckIsLogLevel<
    T extends LogDefinition ? T['level'] : T
  >;

  export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
    ? GetLogType<T[number]>
    : never;

  export type QueryEvent = {
    timestamp: Date
    query: string
    params: string
    duration: number
    target: string
  }

  export type LogEvent = {
    timestamp: Date
    message: string
    target: string
  }
  /* End Types for Logging */


  export type PrismaAction =
    | 'findUnique'
    | 'findUniqueOrThrow'
    | 'findMany'
    | 'findFirst'
    | 'findFirstOrThrow'
    | 'create'
    | 'createMany'
    | 'createManyAndReturn'
    | 'update'
    | 'updateMany'
    | 'updateManyAndReturn'
    | 'upsert'
    | 'delete'
    | 'deleteMany'
    | 'executeRaw'
    | 'queryRaw'
    | 'aggregate'
    | 'count'
    | 'runCommandRaw'
    | 'findRaw'
    | 'groupBy'

  // 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 = {
    patients: number
    appointments: number
    staff: number
    npiProviders: number
    claims: number
    insuranceCredentials: number
    shoppingVendors: number
    updatedPayments: number
    backups: number
    backupDestinations: number
    notifications: number
    cloudFolders: number
    cloudFiles: number
    communications: number
    insuranceContacts: number
    patientConversations: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patients?: boolean | UserCountOutputTypeCountPatientsArgs
    appointments?: boolean | UserCountOutputTypeCountAppointmentsArgs
    staff?: boolean | UserCountOutputTypeCountStaffArgs
    npiProviders?: boolean | UserCountOutputTypeCountNpiProvidersArgs
    claims?: boolean | UserCountOutputTypeCountClaimsArgs
    insuranceCredentials?: boolean | UserCountOutputTypeCountInsuranceCredentialsArgs
    shoppingVendors?: boolean | UserCountOutputTypeCountShoppingVendorsArgs
    updatedPayments?: boolean | UserCountOutputTypeCountUpdatedPaymentsArgs
    backups?: boolean | UserCountOutputTypeCountBackupsArgs
    backupDestinations?: boolean | UserCountOutputTypeCountBackupDestinationsArgs
    notifications?: boolean | UserCountOutputTypeCountNotificationsArgs
    cloudFolders?: boolean | UserCountOutputTypeCountCloudFoldersArgs
    cloudFiles?: boolean | UserCountOutputTypeCountCloudFilesArgs
    communications?: boolean | UserCountOutputTypeCountCommunicationsArgs
    insuranceContacts?: boolean | UserCountOutputTypeCountInsuranceContactsArgs
    patientConversations?: boolean | UserCountOutputTypeCountPatientConversationsArgs
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  /**
   * Count Type PatientCountOutputType
   */

  export type PatientCountOutputType = {
    appointments: number
    procedures: number
    claims: number
    groups: number
    payment: number
    communications: number
    documents: number
  }

  export type PatientCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointments?: boolean | PatientCountOutputTypeCountAppointmentsArgs
    procedures?: boolean | PatientCountOutputTypeCountProceduresArgs
    claims?: boolean | PatientCountOutputTypeCountClaimsArgs
    groups?: boolean | PatientCountOutputTypeCountGroupsArgs
    payment?: boolean | PatientCountOutputTypeCountPaymentArgs
    communications?: boolean | PatientCountOutputTypeCountCommunicationsArgs
    documents?: boolean | PatientCountOutputTypeCountDocumentsArgs
  }

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

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

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountProceduresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentProcedureWhereInput
  }

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountClaimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimWhereInput
  }

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountGroupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PdfGroupWhereInput
  }

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountPaymentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
  }

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountCommunicationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommunicationWhereInput
  }

  /**
   * PatientCountOutputType without action
   */
  export type PatientCountOutputTypeCountDocumentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PatientDocumentWhereInput
  }


  /**
   * Count Type AppointmentCountOutputType
   */

  export type AppointmentCountOutputType = {
    procedures: number
    claims: number
    files: number
  }

  export type AppointmentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    procedures?: boolean | AppointmentCountOutputTypeCountProceduresArgs
    claims?: boolean | AppointmentCountOutputTypeCountClaimsArgs
    files?: boolean | AppointmentCountOutputTypeCountFilesArgs
  }

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

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

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


  /**
   * Count Type StaffCountOutputType
   */

  export type StaffCountOutputType = {
    appointments: number
    claims: number
  }

  export type StaffCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointments?: boolean | StaffCountOutputTypeCountAppointmentsArgs
    claims?: boolean | StaffCountOutputTypeCountClaimsArgs
  }

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

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

  /**
   * StaffCountOutputType without action
   */
  export type StaffCountOutputTypeCountClaimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimWhereInput
  }


  /**
   * Count Type NpiProviderCountOutputType
   */

  export type NpiProviderCountOutputType = {
    claims: number
    payments: number
    commissionBatches: number
    appointmentProcedures: number
  }

  export type NpiProviderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claims?: boolean | NpiProviderCountOutputTypeCountClaimsArgs
    payments?: boolean | NpiProviderCountOutputTypeCountPaymentsArgs
    commissionBatches?: boolean | NpiProviderCountOutputTypeCountCommissionBatchesArgs
    appointmentProcedures?: boolean | NpiProviderCountOutputTypeCountAppointmentProceduresArgs
  }

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

  /**
   * NpiProviderCountOutputType without action
   */
  export type NpiProviderCountOutputTypeCountClaimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimWhereInput
  }

  /**
   * NpiProviderCountOutputType without action
   */
  export type NpiProviderCountOutputTypeCountPaymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
  }

  /**
   * NpiProviderCountOutputType without action
   */
  export type NpiProviderCountOutputTypeCountCommissionBatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionBatchWhereInput
  }

  /**
   * NpiProviderCountOutputType without action
   */
  export type NpiProviderCountOutputTypeCountAppointmentProceduresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentProcedureWhereInput
  }


  /**
   * Count Type ClaimCountOutputType
   */

  export type ClaimCountOutputType = {
    serviceLines: number
    claimFiles: number
  }

  export type ClaimCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    serviceLines?: boolean | ClaimCountOutputTypeCountServiceLinesArgs
    claimFiles?: boolean | ClaimCountOutputTypeCountClaimFilesArgs
  }

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

  /**
   * ClaimCountOutputType without action
   */
  export type ClaimCountOutputTypeCountServiceLinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineWhereInput
  }

  /**
   * ClaimCountOutputType without action
   */
  export type ClaimCountOutputTypeCountClaimFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimFileWhereInput
  }


  /**
   * Count Type ServiceLineCountOutputType
   */

  export type ServiceLineCountOutputType = {
    serviceLineTransactions: number
  }

  export type ServiceLineCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    serviceLineTransactions?: boolean | ServiceLineCountOutputTypeCountServiceLineTransactionsArgs
  }

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

  /**
   * ServiceLineCountOutputType without action
   */
  export type ServiceLineCountOutputTypeCountServiceLineTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineTransactionWhereInput
  }


  /**
   * Count Type PdfGroupCountOutputType
   */

  export type PdfGroupCountOutputType = {
    pdfs: number
  }

  export type PdfGroupCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    pdfs?: boolean | PdfGroupCountOutputTypeCountPdfsArgs
  }

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

  /**
   * PdfGroupCountOutputType without action
   */
  export type PdfGroupCountOutputTypeCountPdfsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PdfFileWhereInput
  }


  /**
   * Count Type PaymentCountOutputType
   */

  export type PaymentCountOutputType = {
    serviceLineTransactions: number
    serviceLines: number
    commissionBatchItems: number
  }

  export type PaymentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    serviceLineTransactions?: boolean | PaymentCountOutputTypeCountServiceLineTransactionsArgs
    serviceLines?: boolean | PaymentCountOutputTypeCountServiceLinesArgs
    commissionBatchItems?: boolean | PaymentCountOutputTypeCountCommissionBatchItemsArgs
  }

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

  /**
   * PaymentCountOutputType without action
   */
  export type PaymentCountOutputTypeCountServiceLineTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineTransactionWhereInput
  }

  /**
   * PaymentCountOutputType without action
   */
  export type PaymentCountOutputTypeCountServiceLinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineWhereInput
  }

  /**
   * PaymentCountOutputType without action
   */
  export type PaymentCountOutputTypeCountCommissionBatchItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionBatchItemWhereInput
  }


  /**
   * Count Type CloudFolderCountOutputType
   */

  export type CloudFolderCountOutputType = {
    children: number
    files: number
  }

  export type CloudFolderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    children?: boolean | CloudFolderCountOutputTypeCountChildrenArgs
    files?: boolean | CloudFolderCountOutputTypeCountFilesArgs
  }

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

  /**
   * CloudFolderCountOutputType without action
   */
  export type CloudFolderCountOutputTypeCountChildrenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFolderWhereInput
  }

  /**
   * CloudFolderCountOutputType without action
   */
  export type CloudFolderCountOutputTypeCountFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFileWhereInput
  }


  /**
   * Count Type CloudFileCountOutputType
   */

  export type CloudFileCountOutputType = {
    chunks: number
  }

  export type CloudFileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    chunks?: boolean | CloudFileCountOutputTypeCountChunksArgs
  }

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

  /**
   * CloudFileCountOutputType without action
   */
  export type CloudFileCountOutputTypeCountChunksArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFileChunkWhereInput
  }


  /**
   * Count Type CommissionBatchCountOutputType
   */

  export type CommissionBatchCountOutputType = {
    items: number
  }

  export type CommissionBatchCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    items?: boolean | CommissionBatchCountOutputTypeCountItemsArgs
  }

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

  /**
   * CommissionBatchCountOutputType without action
   */
  export type CommissionBatchCountOutputTypeCountItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionBatchItemWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

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

  export type UserAvgAggregateOutputType = {
    id: number | null
  }

  export type UserSumAggregateOutputType = {
    id: number | null
  }

  export type UserMinAggregateOutputType = {
    id: number | null
    username: string | null
    password: string | null
    autoBackupEnabled: boolean | null
    usbBackupEnabled: boolean | null
  }

  export type UserMaxAggregateOutputType = {
    id: number | null
    username: string | null
    password: string | null
    autoBackupEnabled: boolean | null
    usbBackupEnabled: boolean | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    username: number
    password: number
    autoBackupEnabled: number
    usbBackupEnabled: number
    _all: number
  }


  export type UserAvgAggregateInputType = {
    id?: true
  }

  export type UserSumAggregateInputType = {
    id?: true
  }

  export type UserMinAggregateInputType = {
    id?: true
    username?: true
    password?: true
    autoBackupEnabled?: true
    usbBackupEnabled?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    username?: true
    password?: true
    autoBackupEnabled?: true
    usbBackupEnabled?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    username?: true
    password?: true
    autoBackupEnabled?: true
    usbBackupEnabled?: 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: number
    username: string
    password: string
    autoBackupEnabled: boolean
    usbBackupEnabled: boolean
    _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
    username?: boolean
    password?: boolean
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: boolean | User$patientsArgs<ExtArgs>
    appointments?: boolean | User$appointmentsArgs<ExtArgs>
    staff?: boolean | User$staffArgs<ExtArgs>
    npiProviders?: boolean | User$npiProvidersArgs<ExtArgs>
    claims?: boolean | User$claimsArgs<ExtArgs>
    insuranceCredentials?: boolean | User$insuranceCredentialsArgs<ExtArgs>
    shoppingVendors?: boolean | User$shoppingVendorsArgs<ExtArgs>
    updatedPayments?: boolean | User$updatedPaymentsArgs<ExtArgs>
    backups?: boolean | User$backupsArgs<ExtArgs>
    backupDestinations?: boolean | User$backupDestinationsArgs<ExtArgs>
    notifications?: boolean | User$notificationsArgs<ExtArgs>
    cloudFolders?: boolean | User$cloudFoldersArgs<ExtArgs>
    cloudFiles?: boolean | User$cloudFilesArgs<ExtArgs>
    communications?: boolean | User$communicationsArgs<ExtArgs>
    twilioSettings?: boolean | User$twilioSettingsArgs<ExtArgs>
    aiSettings?: boolean | User$aiSettingsArgs<ExtArgs>
    officeHours?: boolean | User$officeHoursArgs<ExtArgs>
    officeContact?: boolean | User$officeContactArgs<ExtArgs>
    procedureTimeslot?: boolean | User$procedureTimeslotArgs<ExtArgs>
    insuranceContacts?: boolean | User$insuranceContactsArgs<ExtArgs>
    patientConversations?: boolean | User$patientConversationsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    username?: boolean
    password?: boolean
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    username?: boolean
    password?: boolean
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    username?: boolean
    password?: boolean
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
  }

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "username" | "password" | "autoBackupEnabled" | "usbBackupEnabled", ExtArgs["result"]["user"]>
  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patients?: boolean | User$patientsArgs<ExtArgs>
    appointments?: boolean | User$appointmentsArgs<ExtArgs>
    staff?: boolean | User$staffArgs<ExtArgs>
    npiProviders?: boolean | User$npiProvidersArgs<ExtArgs>
    claims?: boolean | User$claimsArgs<ExtArgs>
    insuranceCredentials?: boolean | User$insuranceCredentialsArgs<ExtArgs>
    shoppingVendors?: boolean | User$shoppingVendorsArgs<ExtArgs>
    updatedPayments?: boolean | User$updatedPaymentsArgs<ExtArgs>
    backups?: boolean | User$backupsArgs<ExtArgs>
    backupDestinations?: boolean | User$backupDestinationsArgs<ExtArgs>
    notifications?: boolean | User$notificationsArgs<ExtArgs>
    cloudFolders?: boolean | User$cloudFoldersArgs<ExtArgs>
    cloudFiles?: boolean | User$cloudFilesArgs<ExtArgs>
    communications?: boolean | User$communicationsArgs<ExtArgs>
    twilioSettings?: boolean | User$twilioSettingsArgs<ExtArgs>
    aiSettings?: boolean | User$aiSettingsArgs<ExtArgs>
    officeHours?: boolean | User$officeHoursArgs<ExtArgs>
    officeContact?: boolean | User$officeContactArgs<ExtArgs>
    procedureTimeslot?: boolean | User$procedureTimeslotArgs<ExtArgs>
    insuranceContacts?: boolean | User$insuranceContactsArgs<ExtArgs>
    patientConversations?: boolean | User$patientConversationsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type UserIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      patients: Prisma.$PatientPayload<ExtArgs>[]
      appointments: Prisma.$AppointmentPayload<ExtArgs>[]
      staff: Prisma.$StaffPayload<ExtArgs>[]
      npiProviders: Prisma.$NpiProviderPayload<ExtArgs>[]
      claims: Prisma.$ClaimPayload<ExtArgs>[]
      insuranceCredentials: Prisma.$InsuranceCredentialPayload<ExtArgs>[]
      shoppingVendors: Prisma.$ShoppingVendorPayload<ExtArgs>[]
      updatedPayments: Prisma.$PaymentPayload<ExtArgs>[]
      backups: Prisma.$DatabaseBackupPayload<ExtArgs>[]
      backupDestinations: Prisma.$BackupDestinationPayload<ExtArgs>[]
      notifications: Prisma.$NotificationPayload<ExtArgs>[]
      cloudFolders: Prisma.$CloudFolderPayload<ExtArgs>[]
      cloudFiles: Prisma.$CloudFilePayload<ExtArgs>[]
      communications: Prisma.$CommunicationPayload<ExtArgs>[]
      twilioSettings: Prisma.$TwilioSettingsPayload<ExtArgs> | null
      aiSettings: Prisma.$AiSettingsPayload<ExtArgs> | null
      officeHours: Prisma.$OfficeHoursPayload<ExtArgs> | null
      officeContact: Prisma.$OfficeContactPayload<ExtArgs> | null
      procedureTimeslot: Prisma.$ProcedureTimeslotPayload<ExtArgs> | null
      insuranceContacts: Prisma.$InsuranceContactPayload<ExtArgs>[]
      patientConversations: Prisma.$PatientConversationPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      username: string
      password: string
      autoBackupEnabled: boolean
      usbBackupEnabled: boolean
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

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

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

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

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

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

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

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

    /**
     * Create a User.
     * @param {UserCreateArgs} args - Arguments to create a User.
     * @example
     * // Create one User
     * const User = await prisma.user.create({
     *   data: {
     *     // ... data to create a User
     *   }
     * })
     * 
     */
    create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a User.
     * @param {UserDeleteArgs} args - Arguments to delete one User.
     * @example
     * // Delete one User
     * const User = await prisma.user.delete({
     *   where: {
     *     // ... filter to delete one User
     *   }
     * })
     * 
     */
    delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>

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

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patients<T extends User$patientsArgs<ExtArgs> = {}>(args?: Subset<T, User$patientsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    appointments<T extends User$appointmentsArgs<ExtArgs> = {}>(args?: Subset<T, User$appointmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    staff<T extends User$staffArgs<ExtArgs> = {}>(args?: Subset<T, User$staffArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    npiProviders<T extends User$npiProvidersArgs<ExtArgs> = {}>(args?: Subset<T, User$npiProvidersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    claims<T extends User$claimsArgs<ExtArgs> = {}>(args?: Subset<T, User$claimsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    insuranceCredentials<T extends User$insuranceCredentialsArgs<ExtArgs> = {}>(args?: Subset<T, User$insuranceCredentialsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceCredentialPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    shoppingVendors<T extends User$shoppingVendorsArgs<ExtArgs> = {}>(args?: Subset<T, User$shoppingVendorsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ShoppingVendorPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    updatedPayments<T extends User$updatedPaymentsArgs<ExtArgs> = {}>(args?: Subset<T, User$updatedPaymentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    backups<T extends User$backupsArgs<ExtArgs> = {}>(args?: Subset<T, User$backupsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DatabaseBackupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    backupDestinations<T extends User$backupDestinationsArgs<ExtArgs> = {}>(args?: Subset<T, User$backupDestinationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BackupDestinationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    notifications<T extends User$notificationsArgs<ExtArgs> = {}>(args?: Subset<T, User$notificationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    cloudFolders<T extends User$cloudFoldersArgs<ExtArgs> = {}>(args?: Subset<T, User$cloudFoldersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    cloudFiles<T extends User$cloudFilesArgs<ExtArgs> = {}>(args?: Subset<T, User$cloudFilesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    communications<T extends User$communicationsArgs<ExtArgs> = {}>(args?: Subset<T, User$communicationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    twilioSettings<T extends User$twilioSettingsArgs<ExtArgs> = {}>(args?: Subset<T, User$twilioSettingsArgs<ExtArgs>>): Prisma__TwilioSettingsClient<$Result.GetResult<Prisma.$TwilioSettingsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    aiSettings<T extends User$aiSettingsArgs<ExtArgs> = {}>(args?: Subset<T, User$aiSettingsArgs<ExtArgs>>): Prisma__AiSettingsClient<$Result.GetResult<Prisma.$AiSettingsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    officeHours<T extends User$officeHoursArgs<ExtArgs> = {}>(args?: Subset<T, User$officeHoursArgs<ExtArgs>>): Prisma__OfficeHoursClient<$Result.GetResult<Prisma.$OfficeHoursPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    officeContact<T extends User$officeContactArgs<ExtArgs> = {}>(args?: Subset<T, User$officeContactArgs<ExtArgs>>): Prisma__OfficeContactClient<$Result.GetResult<Prisma.$OfficeContactPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    procedureTimeslot<T extends User$procedureTimeslotArgs<ExtArgs> = {}>(args?: Subset<T, User$procedureTimeslotArgs<ExtArgs>>): Prisma__ProcedureTimeslotClient<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    insuranceContacts<T extends User$insuranceContactsArgs<ExtArgs> = {}>(args?: Subset<T, User$insuranceContactsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceContactPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    patientConversations<T extends User$patientConversationsArgs<ExtArgs> = {}>(args?: Subset<T, User$patientConversationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the User model
   */
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'Int'>
    readonly username: FieldRef<"User", 'String'>
    readonly password: FieldRef<"User", 'String'>
    readonly autoBackupEnabled: FieldRef<"User", 'Boolean'>
    readonly usbBackupEnabled: FieldRef<"User", 'Boolean'>
  }
    

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

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

  /**
   * User findFirst
   */
  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findFirstOrThrow
   */
  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findMany
   */
  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which Users to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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

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

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

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

  /**
   * User updateManyAndReturn
   */
  export type UserUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

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

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

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

  /**
   * User.patients
   */
  export type User$patientsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    where?: PatientWhereInput
    orderBy?: PatientOrderByWithRelationInput | PatientOrderByWithRelationInput[]
    cursor?: PatientWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PatientScalarFieldEnum | PatientScalarFieldEnum[]
  }

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

  /**
   * User.staff
   */
  export type User$staffArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    where?: StaffWhereInput
    orderBy?: StaffOrderByWithRelationInput | StaffOrderByWithRelationInput[]
    cursor?: StaffWhereUniqueInput
    take?: number
    skip?: number
    distinct?: StaffScalarFieldEnum | StaffScalarFieldEnum[]
  }

  /**
   * User.npiProviders
   */
  export type User$npiProvidersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    where?: NpiProviderWhereInput
    orderBy?: NpiProviderOrderByWithRelationInput | NpiProviderOrderByWithRelationInput[]
    cursor?: NpiProviderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NpiProviderScalarFieldEnum | NpiProviderScalarFieldEnum[]
  }

  /**
   * User.claims
   */
  export type User$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    cursor?: ClaimWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
  }

  /**
   * User.insuranceCredentials
   */
  export type User$insuranceCredentialsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    where?: InsuranceCredentialWhereInput
    orderBy?: InsuranceCredentialOrderByWithRelationInput | InsuranceCredentialOrderByWithRelationInput[]
    cursor?: InsuranceCredentialWhereUniqueInput
    take?: number
    skip?: number
    distinct?: InsuranceCredentialScalarFieldEnum | InsuranceCredentialScalarFieldEnum[]
  }

  /**
   * User.shoppingVendors
   */
  export type User$shoppingVendorsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    where?: ShoppingVendorWhereInput
    orderBy?: ShoppingVendorOrderByWithRelationInput | ShoppingVendorOrderByWithRelationInput[]
    cursor?: ShoppingVendorWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ShoppingVendorScalarFieldEnum | ShoppingVendorScalarFieldEnum[]
  }

  /**
   * User.updatedPayments
   */
  export type User$updatedPaymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    cursor?: PaymentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * User.backups
   */
  export type User$backupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    where?: DatabaseBackupWhereInput
    orderBy?: DatabaseBackupOrderByWithRelationInput | DatabaseBackupOrderByWithRelationInput[]
    cursor?: DatabaseBackupWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DatabaseBackupScalarFieldEnum | DatabaseBackupScalarFieldEnum[]
  }

  /**
   * User.backupDestinations
   */
  export type User$backupDestinationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    where?: BackupDestinationWhereInput
    orderBy?: BackupDestinationOrderByWithRelationInput | BackupDestinationOrderByWithRelationInput[]
    cursor?: BackupDestinationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BackupDestinationScalarFieldEnum | BackupDestinationScalarFieldEnum[]
  }

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

  /**
   * User.cloudFolders
   */
  export type User$cloudFoldersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    where?: CloudFolderWhereInput
    orderBy?: CloudFolderOrderByWithRelationInput | CloudFolderOrderByWithRelationInput[]
    cursor?: CloudFolderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CloudFolderScalarFieldEnum | CloudFolderScalarFieldEnum[]
  }

  /**
   * User.cloudFiles
   */
  export type User$cloudFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    where?: CloudFileWhereInput
    orderBy?: CloudFileOrderByWithRelationInput | CloudFileOrderByWithRelationInput[]
    cursor?: CloudFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CloudFileScalarFieldEnum | CloudFileScalarFieldEnum[]
  }

  /**
   * User.communications
   */
  export type User$communicationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    where?: CommunicationWhereInput
    orderBy?: CommunicationOrderByWithRelationInput | CommunicationOrderByWithRelationInput[]
    cursor?: CommunicationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommunicationScalarFieldEnum | CommunicationScalarFieldEnum[]
  }

  /**
   * User.twilioSettings
   */
  export type User$twilioSettingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    where?: TwilioSettingsWhereInput
  }

  /**
   * User.aiSettings
   */
  export type User$aiSettingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    where?: AiSettingsWhereInput
  }

  /**
   * User.officeHours
   */
  export type User$officeHoursArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    where?: OfficeHoursWhereInput
  }

  /**
   * User.officeContact
   */
  export type User$officeContactArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    where?: OfficeContactWhereInput
  }

  /**
   * User.procedureTimeslot
   */
  export type User$procedureTimeslotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    where?: ProcedureTimeslotWhereInput
  }

  /**
   * User.insuranceContacts
   */
  export type User$insuranceContactsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    where?: InsuranceContactWhereInput
    orderBy?: InsuranceContactOrderByWithRelationInput | InsuranceContactOrderByWithRelationInput[]
    cursor?: InsuranceContactWhereUniqueInput
    take?: number
    skip?: number
    distinct?: InsuranceContactScalarFieldEnum | InsuranceContactScalarFieldEnum[]
  }

  /**
   * User.patientConversations
   */
  export type User$patientConversationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    where?: PatientConversationWhereInput
    orderBy?: PatientConversationOrderByWithRelationInput | PatientConversationOrderByWithRelationInput[]
    cursor?: PatientConversationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PatientConversationScalarFieldEnum | PatientConversationScalarFieldEnum[]
  }

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


  /**
   * Model Patient
   */

  export type AggregatePatient = {
    _count: PatientCountAggregateOutputType | null
    _avg: PatientAvgAggregateOutputType | null
    _sum: PatientSumAggregateOutputType | null
    _min: PatientMinAggregateOutputType | null
    _max: PatientMaxAggregateOutputType | null
  }

  export type PatientAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type PatientSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type PatientMinAggregateOutputType = {
    id: number | null
    firstName: string | null
    lastName: string | null
    dateOfBirth: Date | null
    gender: string | null
    phone: string | null
    email: string | null
    address: string | null
    city: string | null
    zipCode: string | null
    insuranceProvider: string | null
    insuranceId: string | null
    groupNumber: string | null
    policyHolder: string | null
    allergies: string | null
    medicalConditions: string | null
    preferredLanguage: string | null
    status: $Enums.PatientStatus | null
    userId: number | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PatientMaxAggregateOutputType = {
    id: number | null
    firstName: string | null
    lastName: string | null
    dateOfBirth: Date | null
    gender: string | null
    phone: string | null
    email: string | null
    address: string | null
    city: string | null
    zipCode: string | null
    insuranceProvider: string | null
    insuranceId: string | null
    groupNumber: string | null
    policyHolder: string | null
    allergies: string | null
    medicalConditions: string | null
    preferredLanguage: string | null
    status: $Enums.PatientStatus | null
    userId: number | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PatientCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    dateOfBirth: number
    gender: number
    phone: number
    email: number
    address: number
    city: number
    zipCode: number
    insuranceProvider: number
    insuranceId: number
    groupNumber: number
    policyHolder: number
    allergies: number
    medicalConditions: number
    preferredLanguage: number
    status: number
    userId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PatientAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type PatientSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type PatientMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    dateOfBirth?: true
    gender?: true
    phone?: true
    email?: true
    address?: true
    city?: true
    zipCode?: true
    insuranceProvider?: true
    insuranceId?: true
    groupNumber?: true
    policyHolder?: true
    allergies?: true
    medicalConditions?: true
    preferredLanguage?: true
    status?: true
    userId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PatientMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    dateOfBirth?: true
    gender?: true
    phone?: true
    email?: true
    address?: true
    city?: true
    zipCode?: true
    insuranceProvider?: true
    insuranceId?: true
    groupNumber?: true
    policyHolder?: true
    allergies?: true
    medicalConditions?: true
    preferredLanguage?: true
    status?: true
    userId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PatientCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    dateOfBirth?: true
    gender?: true
    phone?: true
    email?: true
    address?: true
    city?: true
    zipCode?: true
    insuranceProvider?: true
    insuranceId?: true
    groupNumber?: true
    policyHolder?: true
    allergies?: true
    medicalConditions?: true
    preferredLanguage?: true
    status?: true
    userId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PatientAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Patient to aggregate.
     */
    where?: PatientWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Patients to fetch.
     */
    orderBy?: PatientOrderByWithRelationInput | PatientOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PatientWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Patients 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` Patients.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Patients
    **/
    _count?: true | PatientCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PatientAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PatientSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PatientMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PatientMaxAggregateInputType
  }

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




  export type PatientGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PatientWhereInput
    orderBy?: PatientOrderByWithAggregationInput | PatientOrderByWithAggregationInput[]
    by: PatientScalarFieldEnum[] | PatientScalarFieldEnum
    having?: PatientScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PatientCountAggregateInputType | true
    _avg?: PatientAvgAggregateInputType
    _sum?: PatientSumAggregateInputType
    _min?: PatientMinAggregateInputType
    _max?: PatientMaxAggregateInputType
  }

  export type PatientGroupByOutputType = {
    id: number
    firstName: string
    lastName: string
    dateOfBirth: Date | null
    gender: string
    phone: string
    email: string | null
    address: string | null
    city: string | null
    zipCode: string | null
    insuranceProvider: string | null
    insuranceId: string | null
    groupNumber: string | null
    policyHolder: string | null
    allergies: string | null
    medicalConditions: string | null
    preferredLanguage: string | null
    status: $Enums.PatientStatus
    userId: number
    createdAt: Date
    updatedAt: Date
    _count: PatientCountAggregateOutputType | null
    _avg: PatientAvgAggregateOutputType | null
    _sum: PatientSumAggregateOutputType | null
    _min: PatientMinAggregateOutputType | null
    _max: PatientMaxAggregateOutputType | null
  }

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


  export type PatientSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    dateOfBirth?: boolean
    gender?: boolean
    phone?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    zipCode?: boolean
    insuranceProvider?: boolean
    insuranceId?: boolean
    groupNumber?: boolean
    policyHolder?: boolean
    allergies?: boolean
    medicalConditions?: boolean
    preferredLanguage?: boolean
    status?: boolean
    userId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    appointments?: boolean | Patient$appointmentsArgs<ExtArgs>
    procedures?: boolean | Patient$proceduresArgs<ExtArgs>
    claims?: boolean | Patient$claimsArgs<ExtArgs>
    groups?: boolean | Patient$groupsArgs<ExtArgs>
    payment?: boolean | Patient$paymentArgs<ExtArgs>
    communications?: boolean | Patient$communicationsArgs<ExtArgs>
    documents?: boolean | Patient$documentsArgs<ExtArgs>
    conversation?: boolean | Patient$conversationArgs<ExtArgs>
    _count?: boolean | PatientCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patient"]>

  export type PatientSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    dateOfBirth?: boolean
    gender?: boolean
    phone?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    zipCode?: boolean
    insuranceProvider?: boolean
    insuranceId?: boolean
    groupNumber?: boolean
    policyHolder?: boolean
    allergies?: boolean
    medicalConditions?: boolean
    preferredLanguage?: boolean
    status?: boolean
    userId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patient"]>

  export type PatientSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    dateOfBirth?: boolean
    gender?: boolean
    phone?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    zipCode?: boolean
    insuranceProvider?: boolean
    insuranceId?: boolean
    groupNumber?: boolean
    policyHolder?: boolean
    allergies?: boolean
    medicalConditions?: boolean
    preferredLanguage?: boolean
    status?: boolean
    userId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patient"]>

  export type PatientSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    dateOfBirth?: boolean
    gender?: boolean
    phone?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    zipCode?: boolean
    insuranceProvider?: boolean
    insuranceId?: boolean
    groupNumber?: boolean
    policyHolder?: boolean
    allergies?: boolean
    medicalConditions?: boolean
    preferredLanguage?: boolean
    status?: boolean
    userId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PatientOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "firstName" | "lastName" | "dateOfBirth" | "gender" | "phone" | "email" | "address" | "city" | "zipCode" | "insuranceProvider" | "insuranceId" | "groupNumber" | "policyHolder" | "allergies" | "medicalConditions" | "preferredLanguage" | "status" | "userId" | "createdAt" | "updatedAt", ExtArgs["result"]["patient"]>
  export type PatientInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    appointments?: boolean | Patient$appointmentsArgs<ExtArgs>
    procedures?: boolean | Patient$proceduresArgs<ExtArgs>
    claims?: boolean | Patient$claimsArgs<ExtArgs>
    groups?: boolean | Patient$groupsArgs<ExtArgs>
    payment?: boolean | Patient$paymentArgs<ExtArgs>
    communications?: boolean | Patient$communicationsArgs<ExtArgs>
    documents?: boolean | Patient$documentsArgs<ExtArgs>
    conversation?: boolean | Patient$conversationArgs<ExtArgs>
    _count?: boolean | PatientCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PatientIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type PatientIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $PatientPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Patient"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      appointments: Prisma.$AppointmentPayload<ExtArgs>[]
      procedures: Prisma.$AppointmentProcedurePayload<ExtArgs>[]
      claims: Prisma.$ClaimPayload<ExtArgs>[]
      groups: Prisma.$PdfGroupPayload<ExtArgs>[]
      payment: Prisma.$PaymentPayload<ExtArgs>[]
      communications: Prisma.$CommunicationPayload<ExtArgs>[]
      documents: Prisma.$PatientDocumentPayload<ExtArgs>[]
      conversation: Prisma.$PatientConversationPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      firstName: string
      lastName: string
      dateOfBirth: Date | null
      gender: string
      phone: string
      email: string | null
      address: string | null
      city: string | null
      zipCode: string | null
      insuranceProvider: string | null
      insuranceId: string | null
      groupNumber: string | null
      policyHolder: string | null
      allergies: string | null
      medicalConditions: string | null
      preferredLanguage: string | null
      status: $Enums.PatientStatus
      userId: number
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["patient"]>
    composites: {}
  }

  type PatientGetPayload<S extends boolean | null | undefined | PatientDefaultArgs> = $Result.GetResult<Prisma.$PatientPayload, S>

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

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

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

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

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

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

    /**
     * Create a Patient.
     * @param {PatientCreateArgs} args - Arguments to create a Patient.
     * @example
     * // Create one Patient
     * const Patient = await prisma.patient.create({
     *   data: {
     *     // ... data to create a Patient
     *   }
     * })
     * 
     */
    create<T extends PatientCreateArgs>(args: SelectSubset<T, PatientCreateArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Patients and returns the data saved in the database.
     * @param {PatientCreateManyAndReturnArgs} args - Arguments to create many Patients.
     * @example
     * // Create many Patients
     * const patient = await prisma.patient.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Patients and only return the `id`
     * const patientWithIdOnly = await prisma.patient.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 PatientCreateManyAndReturnArgs>(args?: SelectSubset<T, PatientCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Patient.
     * @param {PatientDeleteArgs} args - Arguments to delete one Patient.
     * @example
     * // Delete one Patient
     * const Patient = await prisma.patient.delete({
     *   where: {
     *     // ... filter to delete one Patient
     *   }
     * })
     * 
     */
    delete<T extends PatientDeleteArgs>(args: SelectSubset<T, PatientDeleteArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more Patients and returns the data updated in the database.
     * @param {PatientUpdateManyAndReturnArgs} args - Arguments to update many Patients.
     * @example
     * // Update many Patients
     * const patient = await prisma.patient.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Patients and only return the `id`
     * const patientWithIdOnly = await prisma.patient.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PatientUpdateManyAndReturnArgs>(args: SelectSubset<T, PatientUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Patient.
   * 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__PatientClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    appointments<T extends Patient$appointmentsArgs<ExtArgs> = {}>(args?: Subset<T, Patient$appointmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    procedures<T extends Patient$proceduresArgs<ExtArgs> = {}>(args?: Subset<T, Patient$proceduresArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    claims<T extends Patient$claimsArgs<ExtArgs> = {}>(args?: Subset<T, Patient$claimsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    groups<T extends Patient$groupsArgs<ExtArgs> = {}>(args?: Subset<T, Patient$groupsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    payment<T extends Patient$paymentArgs<ExtArgs> = {}>(args?: Subset<T, Patient$paymentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    communications<T extends Patient$communicationsArgs<ExtArgs> = {}>(args?: Subset<T, Patient$communicationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    documents<T extends Patient$documentsArgs<ExtArgs> = {}>(args?: Subset<T, Patient$documentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientDocumentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    conversation<T extends Patient$conversationArgs<ExtArgs> = {}>(args?: Subset<T, Patient$conversationArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Patient model
   */
  interface PatientFieldRefs {
    readonly id: FieldRef<"Patient", 'Int'>
    readonly firstName: FieldRef<"Patient", 'String'>
    readonly lastName: FieldRef<"Patient", 'String'>
    readonly dateOfBirth: FieldRef<"Patient", 'DateTime'>
    readonly gender: FieldRef<"Patient", 'String'>
    readonly phone: FieldRef<"Patient", 'String'>
    readonly email: FieldRef<"Patient", 'String'>
    readonly address: FieldRef<"Patient", 'String'>
    readonly city: FieldRef<"Patient", 'String'>
    readonly zipCode: FieldRef<"Patient", 'String'>
    readonly insuranceProvider: FieldRef<"Patient", 'String'>
    readonly insuranceId: FieldRef<"Patient", 'String'>
    readonly groupNumber: FieldRef<"Patient", 'String'>
    readonly policyHolder: FieldRef<"Patient", 'String'>
    readonly allergies: FieldRef<"Patient", 'String'>
    readonly medicalConditions: FieldRef<"Patient", 'String'>
    readonly preferredLanguage: FieldRef<"Patient", 'String'>
    readonly status: FieldRef<"Patient", 'PatientStatus'>
    readonly userId: FieldRef<"Patient", 'Int'>
    readonly createdAt: FieldRef<"Patient", 'DateTime'>
    readonly updatedAt: FieldRef<"Patient", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Patient findUnique
   */
  export type PatientFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * Filter, which Patient to fetch.
     */
    where: PatientWhereUniqueInput
  }

  /**
   * Patient findUniqueOrThrow
   */
  export type PatientFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * Filter, which Patient to fetch.
     */
    where: PatientWhereUniqueInput
  }

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

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

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

  /**
   * Patient create
   */
  export type PatientCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * The data needed to create a Patient.
     */
    data: XOR<PatientCreateInput, PatientUncheckedCreateInput>
  }

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

  /**
   * Patient createManyAndReturn
   */
  export type PatientCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * The data used to create many Patients.
     */
    data: PatientCreateManyInput | PatientCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Patient update
   */
  export type PatientUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * The data needed to update a Patient.
     */
    data: XOR<PatientUpdateInput, PatientUncheckedUpdateInput>
    /**
     * Choose, which Patient to update.
     */
    where: PatientWhereUniqueInput
  }

  /**
   * Patient updateMany
   */
  export type PatientUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Patients.
     */
    data: XOR<PatientUpdateManyMutationInput, PatientUncheckedUpdateManyInput>
    /**
     * Filter which Patients to update
     */
    where?: PatientWhereInput
    /**
     * Limit how many Patients to update.
     */
    limit?: number
  }

  /**
   * Patient updateManyAndReturn
   */
  export type PatientUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * The data used to update Patients.
     */
    data: XOR<PatientUpdateManyMutationInput, PatientUncheckedUpdateManyInput>
    /**
     * Filter which Patients to update
     */
    where?: PatientWhereInput
    /**
     * Limit how many Patients to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Patient upsert
   */
  export type PatientUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * The filter to search for the Patient to update in case it exists.
     */
    where: PatientWhereUniqueInput
    /**
     * In case the Patient found by the `where` argument doesn't exist, create a new Patient with this data.
     */
    create: XOR<PatientCreateInput, PatientUncheckedCreateInput>
    /**
     * In case the Patient was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PatientUpdateInput, PatientUncheckedUpdateInput>
  }

  /**
   * Patient delete
   */
  export type PatientDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<ExtArgs> | null
    /**
     * Filter which Patient to delete.
     */
    where: PatientWhereUniqueInput
  }

  /**
   * Patient deleteMany
   */
  export type PatientDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Patients to delete
     */
    where?: PatientWhereInput
    /**
     * Limit how many Patients to delete.
     */
    limit?: number
  }

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

  /**
   * Patient.procedures
   */
  export type Patient$proceduresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    where?: AppointmentProcedureWhereInput
    orderBy?: AppointmentProcedureOrderByWithRelationInput | AppointmentProcedureOrderByWithRelationInput[]
    cursor?: AppointmentProcedureWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentProcedureScalarFieldEnum | AppointmentProcedureScalarFieldEnum[]
  }

  /**
   * Patient.claims
   */
  export type Patient$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    cursor?: ClaimWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
  }

  /**
   * Patient.groups
   */
  export type Patient$groupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    where?: PdfGroupWhereInput
    orderBy?: PdfGroupOrderByWithRelationInput | PdfGroupOrderByWithRelationInput[]
    cursor?: PdfGroupWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PdfGroupScalarFieldEnum | PdfGroupScalarFieldEnum[]
  }

  /**
   * Patient.payment
   */
  export type Patient$paymentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    cursor?: PaymentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * Patient.communications
   */
  export type Patient$communicationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    where?: CommunicationWhereInput
    orderBy?: CommunicationOrderByWithRelationInput | CommunicationOrderByWithRelationInput[]
    cursor?: CommunicationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommunicationScalarFieldEnum | CommunicationScalarFieldEnum[]
  }

  /**
   * Patient.documents
   */
  export type Patient$documentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    where?: PatientDocumentWhereInput
    orderBy?: PatientDocumentOrderByWithRelationInput | PatientDocumentOrderByWithRelationInput[]
    cursor?: PatientDocumentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PatientDocumentScalarFieldEnum | PatientDocumentScalarFieldEnum[]
  }

  /**
   * Patient.conversation
   */
  export type Patient$conversationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    where?: PatientConversationWhereInput
  }

  /**
   * Patient without action
   */
  export type PatientDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Patient
     */
    select?: PatientSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Patient
     */
    omit?: PatientOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientInclude<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
    patientId: number | null
    userId: number | null
    staffId: number | null
  }

  export type AppointmentSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    staffId: number | null
  }

  export type AppointmentMinAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    staffId: number | null
    title: string | null
    date: Date | null
    startTime: string | null
    endTime: string | null
    type: string | null
    typeLocked: boolean | null
    notes: string | null
    procedureCodeNotes: string | null
    status: string | null
    movedByAi: boolean | null
    createdAt: Date | null
    eligibilityStatus: $Enums.PatientStatus | null
  }

  export type AppointmentMaxAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    staffId: number | null
    title: string | null
    date: Date | null
    startTime: string | null
    endTime: string | null
    type: string | null
    typeLocked: boolean | null
    notes: string | null
    procedureCodeNotes: string | null
    status: string | null
    movedByAi: boolean | null
    createdAt: Date | null
    eligibilityStatus: $Enums.PatientStatus | null
  }

  export type AppointmentCountAggregateOutputType = {
    id: number
    patientId: number
    userId: number
    staffId: number
    title: number
    date: number
    startTime: number
    endTime: number
    type: number
    typeLocked: number
    notes: number
    procedureCodeNotes: number
    status: number
    movedByAi: number
    createdAt: number
    eligibilityStatus: number
    _all: number
  }


  export type AppointmentAvgAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    staffId?: true
  }

  export type AppointmentSumAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    staffId?: true
  }

  export type AppointmentMinAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    staffId?: true
    title?: true
    date?: true
    startTime?: true
    endTime?: true
    type?: true
    typeLocked?: true
    notes?: true
    procedureCodeNotes?: true
    status?: true
    movedByAi?: true
    createdAt?: true
    eligibilityStatus?: true
  }

  export type AppointmentMaxAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    staffId?: true
    title?: true
    date?: true
    startTime?: true
    endTime?: true
    type?: true
    typeLocked?: true
    notes?: true
    procedureCodeNotes?: true
    status?: true
    movedByAi?: true
    createdAt?: true
    eligibilityStatus?: true
  }

  export type AppointmentCountAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    staffId?: true
    title?: true
    date?: true
    startTime?: true
    endTime?: true
    type?: true
    typeLocked?: true
    notes?: true
    procedureCodeNotes?: true
    status?: true
    movedByAi?: true
    createdAt?: true
    eligibilityStatus?: 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
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date
    startTime: string
    endTime: string
    type: string
    typeLocked: boolean
    notes: string | null
    procedureCodeNotes: string | null
    status: string
    movedByAi: boolean
    createdAt: Date
    eligibilityStatus: $Enums.PatientStatus
    _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
    patientId?: boolean
    userId?: boolean
    staffId?: boolean
    title?: boolean
    date?: boolean
    startTime?: boolean
    endTime?: boolean
    type?: boolean
    typeLocked?: boolean
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: boolean
    movedByAi?: boolean
    createdAt?: boolean
    eligibilityStatus?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
    procedures?: boolean | Appointment$proceduresArgs<ExtArgs>
    claims?: boolean | Appointment$claimsArgs<ExtArgs>
    files?: boolean | Appointment$filesArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    staffId?: boolean
    title?: boolean
    date?: boolean
    startTime?: boolean
    endTime?: boolean
    type?: boolean
    typeLocked?: boolean
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: boolean
    movedByAi?: boolean
    createdAt?: boolean
    eligibilityStatus?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    staffId?: boolean
    title?: boolean
    date?: boolean
    startTime?: boolean
    endTime?: boolean
    type?: boolean
    typeLocked?: boolean
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: boolean
    movedByAi?: boolean
    createdAt?: boolean
    eligibilityStatus?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectScalar = {
    id?: boolean
    patientId?: boolean
    userId?: boolean
    staffId?: boolean
    title?: boolean
    date?: boolean
    startTime?: boolean
    endTime?: boolean
    type?: boolean
    typeLocked?: boolean
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: boolean
    movedByAi?: boolean
    createdAt?: boolean
    eligibilityStatus?: boolean
  }

  export type AppointmentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "patientId" | "userId" | "staffId" | "title" | "date" | "startTime" | "endTime" | "type" | "typeLocked" | "notes" | "procedureCodeNotes" | "status" | "movedByAi" | "createdAt" | "eligibilityStatus", ExtArgs["result"]["appointment"]>
  export type AppointmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
    procedures?: boolean | Appointment$proceduresArgs<ExtArgs>
    claims?: boolean | Appointment$claimsArgs<ExtArgs>
    files?: boolean | Appointment$filesArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type AppointmentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
  }
  export type AppointmentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    staff?: boolean | Appointment$staffArgs<ExtArgs>
  }

  export type $AppointmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Appointment"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
      staff: Prisma.$StaffPayload<ExtArgs> | null
      procedures: Prisma.$AppointmentProcedurePayload<ExtArgs>[]
      claims: Prisma.$ClaimPayload<ExtArgs>[]
      files: Prisma.$AppointmentFilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      userId: number
      staffId: number
      title: string
      date: Date
      startTime: string
      endTime: string
      type: string
      typeLocked: boolean
      notes: string | null
      procedureCodeNotes: string | null
      status: string
      movedByAi: boolean
      createdAt: Date
      eligibilityStatus: $Enums.PatientStatus
    }, ExtArgs["result"]["appointment"]>
    composites: {}
  }

  type AppointmentGetPayload<S extends boolean | null | undefined | AppointmentDefaultArgs> = $Result.GetResult<Prisma.$AppointmentPayload, S>

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

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

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

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

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

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

    /**
     * Create a Appointment.
     * @param {AppointmentCreateArgs} args - Arguments to create a Appointment.
     * @example
     * // Create one Appointment
     * const Appointment = await prisma.appointment.create({
     *   data: {
     *     // ... data to create a Appointment
     *   }
     * })
     * 
     */
    create<T extends AppointmentCreateArgs>(args: SelectSubset<T, AppointmentCreateArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Appointment.
     * @param {AppointmentDeleteArgs} args - Arguments to delete one Appointment.
     * @example
     * // Delete one Appointment
     * const Appointment = await prisma.appointment.delete({
     *   where: {
     *     // ... filter to delete one Appointment
     *   }
     * })
     * 
     */
    delete<T extends AppointmentDeleteArgs>(args: SelectSubset<T, AppointmentDeleteArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a Appointment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends AppointmentAggregateArgs>(args: Subset<T, AppointmentAggregateArgs>): Prisma.PrismaPromise<GetAppointmentAggregateType<T>>

    /**
     * Group by Appointment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends AppointmentGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AppointmentGroupByArgs['orderBy'] }
        : { orderBy?: AppointmentGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, AppointmentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAppointmentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Appointment model
   */
  readonly fields: AppointmentFieldRefs;
  }

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




  /**
   * Fields of the Appointment model
   */
  interface AppointmentFieldRefs {
    readonly id: FieldRef<"Appointment", 'Int'>
    readonly patientId: FieldRef<"Appointment", 'Int'>
    readonly userId: FieldRef<"Appointment", 'Int'>
    readonly staffId: FieldRef<"Appointment", 'Int'>
    readonly title: FieldRef<"Appointment", 'String'>
    readonly date: FieldRef<"Appointment", 'DateTime'>
    readonly startTime: FieldRef<"Appointment", 'String'>
    readonly endTime: FieldRef<"Appointment", 'String'>
    readonly type: FieldRef<"Appointment", 'String'>
    readonly typeLocked: FieldRef<"Appointment", 'Boolean'>
    readonly notes: FieldRef<"Appointment", 'String'>
    readonly procedureCodeNotes: FieldRef<"Appointment", 'String'>
    readonly status: FieldRef<"Appointment", 'String'>
    readonly movedByAi: FieldRef<"Appointment", 'Boolean'>
    readonly createdAt: FieldRef<"Appointment", 'DateTime'>
    readonly eligibilityStatus: FieldRef<"Appointment", 'PatientStatus'>
  }
    

  // Custom InputTypes
  /**
   * Appointment findUnique
   */
  export type AppointmentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment findUniqueOrThrow
   */
  export type AppointmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment findFirst
   */
  export type AppointmentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Appointments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Appointments.
     */
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment findFirstOrThrow
   */
  export type AppointmentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Appointments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Appointments.
     */
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment findMany
   */
  export type AppointmentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointments to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Appointments.
     */
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment create
   */
  export type AppointmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to create a Appointment.
     */
    data: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
  }

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

  /**
   * Appointment createManyAndReturn
   */
  export type AppointmentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<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
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to update a Appointment.
     */
    data: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
    /**
     * Choose, which Appointment to update.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment updateMany
   */
  export type AppointmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Appointments.
     */
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyInput>
    /**
     * Filter which Appointments to update
     */
    where?: AppointmentWhereInput
    /**
     * Limit how many Appointments to update.
     */
    limit?: number
  }

  /**
   * Appointment updateManyAndReturn
   */
  export type AppointmentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * The data used to update Appointments.
     */
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyInput>
    /**
     * Filter which Appointments to update
     */
    where?: AppointmentWhereInput
    /**
     * Limit how many Appointments to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Appointment upsert
   */
  export type AppointmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The filter to search for the Appointment to update in case it exists.
     */
    where: AppointmentWhereUniqueInput
    /**
     * In case the Appointment found by the `where` argument doesn't exist, create a new Appointment with this data.
     */
    create: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
    /**
     * In case the Appointment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
  }

  /**
   * Appointment delete
   */
  export type AppointmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter which Appointment to delete.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment deleteMany
   */
  export type AppointmentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Appointments to delete
     */
    where?: AppointmentWhereInput
    /**
     * Limit how many Appointments to delete.
     */
    limit?: number
  }

  /**
   * Appointment.staff
   */
  export type Appointment$staffArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    where?: StaffWhereInput
  }

  /**
   * Appointment.procedures
   */
  export type Appointment$proceduresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    where?: AppointmentProcedureWhereInput
    orderBy?: AppointmentProcedureOrderByWithRelationInput | AppointmentProcedureOrderByWithRelationInput[]
    cursor?: AppointmentProcedureWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentProcedureScalarFieldEnum | AppointmentProcedureScalarFieldEnum[]
  }

  /**
   * Appointment.claims
   */
  export type Appointment$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    cursor?: ClaimWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
  }

  /**
   * Appointment.files
   */
  export type Appointment$filesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    where?: AppointmentFileWhereInput
    orderBy?: AppointmentFileOrderByWithRelationInput | AppointmentFileOrderByWithRelationInput[]
    cursor?: AppointmentFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentFileScalarFieldEnum | AppointmentFileScalarFieldEnum[]
  }

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


  /**
   * Model AppointmentFile
   */

  export type AggregateAppointmentFile = {
    _count: AppointmentFileCountAggregateOutputType | null
    _avg: AppointmentFileAvgAggregateOutputType | null
    _sum: AppointmentFileSumAggregateOutputType | null
    _min: AppointmentFileMinAggregateOutputType | null
    _max: AppointmentFileMaxAggregateOutputType | null
  }

  export type AppointmentFileAvgAggregateOutputType = {
    id: number | null
    appointmentId: number | null
  }

  export type AppointmentFileSumAggregateOutputType = {
    id: number | null
    appointmentId: number | null
  }

  export type AppointmentFileMinAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    filename: string | null
    mimeType: string | null
    filePath: string | null
  }

  export type AppointmentFileMaxAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    filename: string | null
    mimeType: string | null
    filePath: string | null
  }

  export type AppointmentFileCountAggregateOutputType = {
    id: number
    appointmentId: number
    filename: number
    mimeType: number
    filePath: number
    _all: number
  }


  export type AppointmentFileAvgAggregateInputType = {
    id?: true
    appointmentId?: true
  }

  export type AppointmentFileSumAggregateInputType = {
    id?: true
    appointmentId?: true
  }

  export type AppointmentFileMinAggregateInputType = {
    id?: true
    appointmentId?: true
    filename?: true
    mimeType?: true
    filePath?: true
  }

  export type AppointmentFileMaxAggregateInputType = {
    id?: true
    appointmentId?: true
    filename?: true
    mimeType?: true
    filePath?: true
  }

  export type AppointmentFileCountAggregateInputType = {
    id?: true
    appointmentId?: true
    filename?: true
    mimeType?: true
    filePath?: true
    _all?: true
  }

  export type AppointmentFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentFile to aggregate.
     */
    where?: AppointmentFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AppointmentFiles to fetch.
     */
    orderBy?: AppointmentFileOrderByWithRelationInput | AppointmentFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AppointmentFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AppointmentFiles 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` AppointmentFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AppointmentFiles
    **/
    _count?: true | AppointmentFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AppointmentFileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AppointmentFileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AppointmentFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AppointmentFileMaxAggregateInputType
  }

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




  export type AppointmentFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentFileWhereInput
    orderBy?: AppointmentFileOrderByWithAggregationInput | AppointmentFileOrderByWithAggregationInput[]
    by: AppointmentFileScalarFieldEnum[] | AppointmentFileScalarFieldEnum
    having?: AppointmentFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentFileCountAggregateInputType | true
    _avg?: AppointmentFileAvgAggregateInputType
    _sum?: AppointmentFileSumAggregateInputType
    _min?: AppointmentFileMinAggregateInputType
    _max?: AppointmentFileMaxAggregateInputType
  }

  export type AppointmentFileGroupByOutputType = {
    id: number
    appointmentId: number
    filename: string
    mimeType: string | null
    filePath: string | null
    _count: AppointmentFileCountAggregateOutputType | null
    _avg: AppointmentFileAvgAggregateOutputType | null
    _sum: AppointmentFileSumAggregateOutputType | null
    _min: AppointmentFileMinAggregateOutputType | null
    _max: AppointmentFileMaxAggregateOutputType | null
  }

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


  export type AppointmentFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentFile"]>

  export type AppointmentFileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentFile"]>

  export type AppointmentFileSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentFile"]>

  export type AppointmentFileSelectScalar = {
    id?: boolean
    appointmentId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
  }

  export type AppointmentFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "appointmentId" | "filename" | "mimeType" | "filePath", ExtArgs["result"]["appointmentFile"]>
  export type AppointmentFileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }
  export type AppointmentFileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }
  export type AppointmentFileIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }

  export type $AppointmentFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentFile"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      appointmentId: number
      filename: string
      mimeType: string | null
      filePath: string | null
    }, ExtArgs["result"]["appointmentFile"]>
    composites: {}
  }

  type AppointmentFileGetPayload<S extends boolean | null | undefined | AppointmentFileDefaultArgs> = $Result.GetResult<Prisma.$AppointmentFilePayload, S>

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

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

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

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

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

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

    /**
     * Create a AppointmentFile.
     * @param {AppointmentFileCreateArgs} args - Arguments to create a AppointmentFile.
     * @example
     * // Create one AppointmentFile
     * const AppointmentFile = await prisma.appointmentFile.create({
     *   data: {
     *     // ... data to create a AppointmentFile
     *   }
     * })
     * 
     */
    create<T extends AppointmentFileCreateArgs>(args: SelectSubset<T, AppointmentFileCreateArgs<ExtArgs>>): Prisma__AppointmentFileClient<$Result.GetResult<Prisma.$AppointmentFilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AppointmentFiles and returns the data saved in the database.
     * @param {AppointmentFileCreateManyAndReturnArgs} args - Arguments to create many AppointmentFiles.
     * @example
     * // Create many AppointmentFiles
     * const appointmentFile = await prisma.appointmentFile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AppointmentFiles and only return the `id`
     * const appointmentFileWithIdOnly = await prisma.appointmentFile.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 AppointmentFileCreateManyAndReturnArgs>(args?: SelectSubset<T, AppointmentFileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentFilePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AppointmentFile.
     * @param {AppointmentFileDeleteArgs} args - Arguments to delete one AppointmentFile.
     * @example
     * // Delete one AppointmentFile
     * const AppointmentFile = await prisma.appointmentFile.delete({
     *   where: {
     *     // ... filter to delete one AppointmentFile
     *   }
     * })
     * 
     */
    delete<T extends AppointmentFileDeleteArgs>(args: SelectSubset<T, AppointmentFileDeleteArgs<ExtArgs>>): Prisma__AppointmentFileClient<$Result.GetResult<Prisma.$AppointmentFilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more AppointmentFiles and returns the data updated in the database.
     * @param {AppointmentFileUpdateManyAndReturnArgs} args - Arguments to update many AppointmentFiles.
     * @example
     * // Update many AppointmentFiles
     * const appointmentFile = await prisma.appointmentFile.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AppointmentFiles and only return the `id`
     * const appointmentFileWithIdOnly = await prisma.appointmentFile.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AppointmentFileUpdateManyAndReturnArgs>(args: SelectSubset<T, AppointmentFileUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentFilePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppointmentFile.
   * 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__AppointmentFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> 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", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the AppointmentFile model
   */
  interface AppointmentFileFieldRefs {
    readonly id: FieldRef<"AppointmentFile", 'Int'>
    readonly appointmentId: FieldRef<"AppointmentFile", 'Int'>
    readonly filename: FieldRef<"AppointmentFile", 'String'>
    readonly mimeType: FieldRef<"AppointmentFile", 'String'>
    readonly filePath: FieldRef<"AppointmentFile", 'String'>
  }
    

  // Custom InputTypes
  /**
   * AppointmentFile findUnique
   */
  export type AppointmentFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentFile to fetch.
     */
    where: AppointmentFileWhereUniqueInput
  }

  /**
   * AppointmentFile findUniqueOrThrow
   */
  export type AppointmentFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentFile to fetch.
     */
    where: AppointmentFileWhereUniqueInput
  }

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

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

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

  /**
   * AppointmentFile create
   */
  export type AppointmentFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * The data needed to create a AppointmentFile.
     */
    data: XOR<AppointmentFileCreateInput, AppointmentFileUncheckedCreateInput>
  }

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

  /**
   * AppointmentFile createManyAndReturn
   */
  export type AppointmentFileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * The data used to create many AppointmentFiles.
     */
    data: AppointmentFileCreateManyInput | AppointmentFileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AppointmentFile update
   */
  export type AppointmentFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * The data needed to update a AppointmentFile.
     */
    data: XOR<AppointmentFileUpdateInput, AppointmentFileUncheckedUpdateInput>
    /**
     * Choose, which AppointmentFile to update.
     */
    where: AppointmentFileWhereUniqueInput
  }

  /**
   * AppointmentFile updateMany
   */
  export type AppointmentFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppointmentFiles.
     */
    data: XOR<AppointmentFileUpdateManyMutationInput, AppointmentFileUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentFiles to update
     */
    where?: AppointmentFileWhereInput
    /**
     * Limit how many AppointmentFiles to update.
     */
    limit?: number
  }

  /**
   * AppointmentFile updateManyAndReturn
   */
  export type AppointmentFileUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * The data used to update AppointmentFiles.
     */
    data: XOR<AppointmentFileUpdateManyMutationInput, AppointmentFileUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentFiles to update
     */
    where?: AppointmentFileWhereInput
    /**
     * Limit how many AppointmentFiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * AppointmentFile upsert
   */
  export type AppointmentFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * The filter to search for the AppointmentFile to update in case it exists.
     */
    where: AppointmentFileWhereUniqueInput
    /**
     * In case the AppointmentFile found by the `where` argument doesn't exist, create a new AppointmentFile with this data.
     */
    create: XOR<AppointmentFileCreateInput, AppointmentFileUncheckedCreateInput>
    /**
     * In case the AppointmentFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentFileUpdateInput, AppointmentFileUncheckedUpdateInput>
  }

  /**
   * AppointmentFile delete
   */
  export type AppointmentFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentFile
     */
    select?: AppointmentFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentFile
     */
    omit?: AppointmentFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentFileInclude<ExtArgs> | null
    /**
     * Filter which AppointmentFile to delete.
     */
    where: AppointmentFileWhereUniqueInput
  }

  /**
   * AppointmentFile deleteMany
   */
  export type AppointmentFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentFiles to delete
     */
    where?: AppointmentFileWhereInput
    /**
     * Limit how many AppointmentFiles to delete.
     */
    limit?: number
  }

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


  /**
   * Model Staff
   */

  export type AggregateStaff = {
    _count: StaffCountAggregateOutputType | null
    _avg: StaffAvgAggregateOutputType | null
    _sum: StaffSumAggregateOutputType | null
    _min: StaffMinAggregateOutputType | null
    _max: StaffMaxAggregateOutputType | null
  }

  export type StaffAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type StaffSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type StaffMinAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    email: string | null
    role: string | null
    phone: string | null
    createdAt: Date | null
  }

  export type StaffMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    email: string | null
    role: string | null
    phone: string | null
    createdAt: Date | null
  }

  export type StaffCountAggregateOutputType = {
    id: number
    userId: number
    name: number
    email: number
    role: number
    phone: number
    createdAt: number
    _all: number
  }


  export type StaffAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type StaffSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type StaffMinAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    email?: true
    role?: true
    phone?: true
    createdAt?: true
  }

  export type StaffMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    email?: true
    role?: true
    phone?: true
    createdAt?: true
  }

  export type StaffCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    email?: true
    role?: true
    phone?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type StaffGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: StaffWhereInput
    orderBy?: StaffOrderByWithAggregationInput | StaffOrderByWithAggregationInput[]
    by: StaffScalarFieldEnum[] | StaffScalarFieldEnum
    having?: StaffScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: StaffCountAggregateInputType | true
    _avg?: StaffAvgAggregateInputType
    _sum?: StaffSumAggregateInputType
    _min?: StaffMinAggregateInputType
    _max?: StaffMaxAggregateInputType
  }

  export type StaffGroupByOutputType = {
    id: number
    userId: number
    name: string
    email: string | null
    role: string
    phone: string | null
    createdAt: Date
    _count: StaffCountAggregateOutputType | null
    _avg: StaffAvgAggregateOutputType | null
    _sum: StaffSumAggregateOutputType | null
    _min: StaffMinAggregateOutputType | null
    _max: StaffMaxAggregateOutputType | null
  }

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


  export type StaffSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    email?: boolean
    role?: boolean
    phone?: boolean
    createdAt?: boolean
    user?: boolean | Staff$userArgs<ExtArgs>
    appointments?: boolean | Staff$appointmentsArgs<ExtArgs>
    claims?: boolean | Staff$claimsArgs<ExtArgs>
    _count?: boolean | StaffCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["staff"]>

  export type StaffSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    email?: boolean
    role?: boolean
    phone?: boolean
    createdAt?: boolean
    user?: boolean | Staff$userArgs<ExtArgs>
  }, ExtArgs["result"]["staff"]>

  export type StaffSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    email?: boolean
    role?: boolean
    phone?: boolean
    createdAt?: boolean
    user?: boolean | Staff$userArgs<ExtArgs>
  }, ExtArgs["result"]["staff"]>

  export type StaffSelectScalar = {
    id?: boolean
    userId?: boolean
    name?: boolean
    email?: boolean
    role?: boolean
    phone?: boolean
    createdAt?: boolean
  }

  export type StaffOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "name" | "email" | "role" | "phone" | "createdAt", ExtArgs["result"]["staff"]>
  export type StaffInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Staff$userArgs<ExtArgs>
    appointments?: boolean | Staff$appointmentsArgs<ExtArgs>
    claims?: boolean | Staff$claimsArgs<ExtArgs>
    _count?: boolean | StaffCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type StaffIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Staff$userArgs<ExtArgs>
  }
  export type StaffIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Staff$userArgs<ExtArgs>
  }

  export type $StaffPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Staff"
    objects: {
      user: Prisma.$UserPayload<ExtArgs> | null
      appointments: Prisma.$AppointmentPayload<ExtArgs>[]
      claims: Prisma.$ClaimPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      name: string
      email: string | null
      role: string
      phone: string | null
      createdAt: Date
    }, ExtArgs["result"]["staff"]>
    composites: {}
  }

  type StaffGetPayload<S extends boolean | null | undefined | StaffDefaultArgs> = $Result.GetResult<Prisma.$StaffPayload, S>

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

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

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

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

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

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

    /**
     * Create a Staff.
     * @param {StaffCreateArgs} args - Arguments to create a Staff.
     * @example
     * // Create one Staff
     * const Staff = await prisma.staff.create({
     *   data: {
     *     // ... data to create a Staff
     *   }
     * })
     * 
     */
    create<T extends StaffCreateArgs>(args: SelectSubset<T, StaffCreateArgs<ExtArgs>>): Prisma__StaffClient<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Staff and returns the data saved in the database.
     * @param {StaffCreateManyAndReturnArgs} args - Arguments to create many Staff.
     * @example
     * // Create many Staff
     * const staff = await prisma.staff.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Staff and only return the `id`
     * const staffWithIdOnly = await prisma.staff.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 StaffCreateManyAndReturnArgs>(args?: SelectSubset<T, StaffCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Staff.
     * @param {StaffDeleteArgs} args - Arguments to delete one Staff.
     * @example
     * // Delete one Staff
     * const Staff = await prisma.staff.delete({
     *   where: {
     *     // ... filter to delete one Staff
     *   }
     * })
     * 
     */
    delete<T extends StaffDeleteArgs>(args: SelectSubset<T, StaffDeleteArgs<ExtArgs>>): Prisma__StaffClient<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more Staff and returns the data updated in the database.
     * @param {StaffUpdateManyAndReturnArgs} args - Arguments to update many Staff.
     * @example
     * // Update many Staff
     * const staff = await prisma.staff.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Staff and only return the `id`
     * const staffWithIdOnly = await prisma.staff.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends StaffUpdateManyAndReturnArgs>(args: SelectSubset<T, StaffUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Staff.
   * 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__StaffClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends Staff$userArgs<ExtArgs> = {}>(args?: Subset<T, Staff$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    appointments<T extends Staff$appointmentsArgs<ExtArgs> = {}>(args?: Subset<T, Staff$appointmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    claims<T extends Staff$claimsArgs<ExtArgs> = {}>(args?: Subset<T, Staff$claimsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Staff model
   */
  interface StaffFieldRefs {
    readonly id: FieldRef<"Staff", 'Int'>
    readonly userId: FieldRef<"Staff", 'Int'>
    readonly name: FieldRef<"Staff", 'String'>
    readonly email: FieldRef<"Staff", 'String'>
    readonly role: FieldRef<"Staff", 'String'>
    readonly phone: FieldRef<"Staff", 'String'>
    readonly createdAt: FieldRef<"Staff", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Staff findUnique
   */
  export type StaffFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * Filter, which Staff to fetch.
     */
    where: StaffWhereUniqueInput
  }

  /**
   * Staff findUniqueOrThrow
   */
  export type StaffFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * Filter, which Staff to fetch.
     */
    where: StaffWhereUniqueInput
  }

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

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

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

  /**
   * Staff create
   */
  export type StaffCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * The data needed to create a Staff.
     */
    data: XOR<StaffCreateInput, StaffUncheckedCreateInput>
  }

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

  /**
   * Staff createManyAndReturn
   */
  export type StaffCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * The data used to create many Staff.
     */
    data: StaffCreateManyInput | StaffCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Staff update
   */
  export type StaffUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * The data needed to update a Staff.
     */
    data: XOR<StaffUpdateInput, StaffUncheckedUpdateInput>
    /**
     * Choose, which Staff to update.
     */
    where: StaffWhereUniqueInput
  }

  /**
   * Staff updateMany
   */
  export type StaffUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Staff.
     */
    data: XOR<StaffUpdateManyMutationInput, StaffUncheckedUpdateManyInput>
    /**
     * Filter which Staff to update
     */
    where?: StaffWhereInput
    /**
     * Limit how many Staff to update.
     */
    limit?: number
  }

  /**
   * Staff updateManyAndReturn
   */
  export type StaffUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * The data used to update Staff.
     */
    data: XOR<StaffUpdateManyMutationInput, StaffUncheckedUpdateManyInput>
    /**
     * Filter which Staff to update
     */
    where?: StaffWhereInput
    /**
     * Limit how many Staff to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Staff upsert
   */
  export type StaffUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * The filter to search for the Staff to update in case it exists.
     */
    where: StaffWhereUniqueInput
    /**
     * In case the Staff found by the `where` argument doesn't exist, create a new Staff with this data.
     */
    create: XOR<StaffCreateInput, StaffUncheckedCreateInput>
    /**
     * In case the Staff was found with the provided `where` argument, update it with this data.
     */
    update: XOR<StaffUpdateInput, StaffUncheckedUpdateInput>
  }

  /**
   * Staff delete
   */
  export type StaffDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    /**
     * Filter which Staff to delete.
     */
    where: StaffWhereUniqueInput
  }

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

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

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

  /**
   * Staff.claims
   */
  export type Staff$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    cursor?: ClaimWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
  }

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


  /**
   * Model NpiProvider
   */

  export type AggregateNpiProvider = {
    _count: NpiProviderCountAggregateOutputType | null
    _avg: NpiProviderAvgAggregateOutputType | null
    _sum: NpiProviderSumAggregateOutputType | null
    _min: NpiProviderMinAggregateOutputType | null
    _max: NpiProviderMaxAggregateOutputType | null
  }

  export type NpiProviderAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type NpiProviderSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type NpiProviderMinAggregateOutputType = {
    id: number | null
    userId: number | null
    npiNumber: string | null
    providerName: string | null
    createdAt: Date | null
  }

  export type NpiProviderMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    npiNumber: string | null
    providerName: string | null
    createdAt: Date | null
  }

  export type NpiProviderCountAggregateOutputType = {
    id: number
    userId: number
    npiNumber: number
    providerName: number
    createdAt: number
    _all: number
  }


  export type NpiProviderAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type NpiProviderSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type NpiProviderMinAggregateInputType = {
    id?: true
    userId?: true
    npiNumber?: true
    providerName?: true
    createdAt?: true
  }

  export type NpiProviderMaxAggregateInputType = {
    id?: true
    userId?: true
    npiNumber?: true
    providerName?: true
    createdAt?: true
  }

  export type NpiProviderCountAggregateInputType = {
    id?: true
    userId?: true
    npiNumber?: true
    providerName?: true
    createdAt?: true
    _all?: true
  }

  export type NpiProviderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NpiProvider to aggregate.
     */
    where?: NpiProviderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NpiProviders to fetch.
     */
    orderBy?: NpiProviderOrderByWithRelationInput | NpiProviderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NpiProviderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NpiProviders 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` NpiProviders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned NpiProviders
    **/
    _count?: true | NpiProviderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: NpiProviderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: NpiProviderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NpiProviderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NpiProviderMaxAggregateInputType
  }

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




  export type NpiProviderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NpiProviderWhereInput
    orderBy?: NpiProviderOrderByWithAggregationInput | NpiProviderOrderByWithAggregationInput[]
    by: NpiProviderScalarFieldEnum[] | NpiProviderScalarFieldEnum
    having?: NpiProviderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NpiProviderCountAggregateInputType | true
    _avg?: NpiProviderAvgAggregateInputType
    _sum?: NpiProviderSumAggregateInputType
    _min?: NpiProviderMinAggregateInputType
    _max?: NpiProviderMaxAggregateInputType
  }

  export type NpiProviderGroupByOutputType = {
    id: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt: Date
    _count: NpiProviderCountAggregateOutputType | null
    _avg: NpiProviderAvgAggregateOutputType | null
    _sum: NpiProviderSumAggregateOutputType | null
    _min: NpiProviderMinAggregateOutputType | null
    _max: NpiProviderMaxAggregateOutputType | null
  }

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


  export type NpiProviderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    npiNumber?: boolean
    providerName?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    claims?: boolean | NpiProvider$claimsArgs<ExtArgs>
    payments?: boolean | NpiProvider$paymentsArgs<ExtArgs>
    commissionBatches?: boolean | NpiProvider$commissionBatchesArgs<ExtArgs>
    appointmentProcedures?: boolean | NpiProvider$appointmentProceduresArgs<ExtArgs>
    _count?: boolean | NpiProviderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["npiProvider"]>

  export type NpiProviderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    npiNumber?: boolean
    providerName?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["npiProvider"]>

  export type NpiProviderSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    npiNumber?: boolean
    providerName?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["npiProvider"]>

  export type NpiProviderSelectScalar = {
    id?: boolean
    userId?: boolean
    npiNumber?: boolean
    providerName?: boolean
    createdAt?: boolean
  }

  export type NpiProviderOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "npiNumber" | "providerName" | "createdAt", ExtArgs["result"]["npiProvider"]>
  export type NpiProviderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    claims?: boolean | NpiProvider$claimsArgs<ExtArgs>
    payments?: boolean | NpiProvider$paymentsArgs<ExtArgs>
    commissionBatches?: boolean | NpiProvider$commissionBatchesArgs<ExtArgs>
    appointmentProcedures?: boolean | NpiProvider$appointmentProceduresArgs<ExtArgs>
    _count?: boolean | NpiProviderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type NpiProviderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type NpiProviderIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $NpiProviderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "NpiProvider"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      claims: Prisma.$ClaimPayload<ExtArgs>[]
      payments: Prisma.$PaymentPayload<ExtArgs>[]
      commissionBatches: Prisma.$CommissionBatchPayload<ExtArgs>[]
      appointmentProcedures: Prisma.$AppointmentProcedurePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      npiNumber: string
      providerName: string
      createdAt: Date
    }, ExtArgs["result"]["npiProvider"]>
    composites: {}
  }

  type NpiProviderGetPayload<S extends boolean | null | undefined | NpiProviderDefaultArgs> = $Result.GetResult<Prisma.$NpiProviderPayload, S>

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

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

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

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

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

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

    /**
     * Create a NpiProvider.
     * @param {NpiProviderCreateArgs} args - Arguments to create a NpiProvider.
     * @example
     * // Create one NpiProvider
     * const NpiProvider = await prisma.npiProvider.create({
     *   data: {
     *     // ... data to create a NpiProvider
     *   }
     * })
     * 
     */
    create<T extends NpiProviderCreateArgs>(args: SelectSubset<T, NpiProviderCreateArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many NpiProviders and returns the data saved in the database.
     * @param {NpiProviderCreateManyAndReturnArgs} args - Arguments to create many NpiProviders.
     * @example
     * // Create many NpiProviders
     * const npiProvider = await prisma.npiProvider.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many NpiProviders and only return the `id`
     * const npiProviderWithIdOnly = await prisma.npiProvider.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 NpiProviderCreateManyAndReturnArgs>(args?: SelectSubset<T, NpiProviderCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a NpiProvider.
     * @param {NpiProviderDeleteArgs} args - Arguments to delete one NpiProvider.
     * @example
     * // Delete one NpiProvider
     * const NpiProvider = await prisma.npiProvider.delete({
     *   where: {
     *     // ... filter to delete one NpiProvider
     *   }
     * })
     * 
     */
    delete<T extends NpiProviderDeleteArgs>(args: SelectSubset<T, NpiProviderDeleteArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more NpiProviders and returns the data updated in the database.
     * @param {NpiProviderUpdateManyAndReturnArgs} args - Arguments to update many NpiProviders.
     * @example
     * // Update many NpiProviders
     * const npiProvider = await prisma.npiProvider.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more NpiProviders and only return the `id`
     * const npiProviderWithIdOnly = await prisma.npiProvider.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends NpiProviderUpdateManyAndReturnArgs>(args: SelectSubset<T, NpiProviderUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for NpiProvider.
   * 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__NpiProviderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    claims<T extends NpiProvider$claimsArgs<ExtArgs> = {}>(args?: Subset<T, NpiProvider$claimsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    payments<T extends NpiProvider$paymentsArgs<ExtArgs> = {}>(args?: Subset<T, NpiProvider$paymentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    commissionBatches<T extends NpiProvider$commissionBatchesArgs<ExtArgs> = {}>(args?: Subset<T, NpiProvider$commissionBatchesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    appointmentProcedures<T extends NpiProvider$appointmentProceduresArgs<ExtArgs> = {}>(args?: Subset<T, NpiProvider$appointmentProceduresArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the NpiProvider model
   */
  interface NpiProviderFieldRefs {
    readonly id: FieldRef<"NpiProvider", 'Int'>
    readonly userId: FieldRef<"NpiProvider", 'Int'>
    readonly npiNumber: FieldRef<"NpiProvider", 'String'>
    readonly providerName: FieldRef<"NpiProvider", 'String'>
    readonly createdAt: FieldRef<"NpiProvider", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * NpiProvider findUnique
   */
  export type NpiProviderFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * Filter, which NpiProvider to fetch.
     */
    where: NpiProviderWhereUniqueInput
  }

  /**
   * NpiProvider findUniqueOrThrow
   */
  export type NpiProviderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * Filter, which NpiProvider to fetch.
     */
    where: NpiProviderWhereUniqueInput
  }

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

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

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

  /**
   * NpiProvider create
   */
  export type NpiProviderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * The data needed to create a NpiProvider.
     */
    data: XOR<NpiProviderCreateInput, NpiProviderUncheckedCreateInput>
  }

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

  /**
   * NpiProvider createManyAndReturn
   */
  export type NpiProviderCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * The data used to create many NpiProviders.
     */
    data: NpiProviderCreateManyInput | NpiProviderCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * NpiProvider update
   */
  export type NpiProviderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * The data needed to update a NpiProvider.
     */
    data: XOR<NpiProviderUpdateInput, NpiProviderUncheckedUpdateInput>
    /**
     * Choose, which NpiProvider to update.
     */
    where: NpiProviderWhereUniqueInput
  }

  /**
   * NpiProvider updateMany
   */
  export type NpiProviderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update NpiProviders.
     */
    data: XOR<NpiProviderUpdateManyMutationInput, NpiProviderUncheckedUpdateManyInput>
    /**
     * Filter which NpiProviders to update
     */
    where?: NpiProviderWhereInput
    /**
     * Limit how many NpiProviders to update.
     */
    limit?: number
  }

  /**
   * NpiProvider updateManyAndReturn
   */
  export type NpiProviderUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * The data used to update NpiProviders.
     */
    data: XOR<NpiProviderUpdateManyMutationInput, NpiProviderUncheckedUpdateManyInput>
    /**
     * Filter which NpiProviders to update
     */
    where?: NpiProviderWhereInput
    /**
     * Limit how many NpiProviders to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * NpiProvider upsert
   */
  export type NpiProviderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * The filter to search for the NpiProvider to update in case it exists.
     */
    where: NpiProviderWhereUniqueInput
    /**
     * In case the NpiProvider found by the `where` argument doesn't exist, create a new NpiProvider with this data.
     */
    create: XOR<NpiProviderCreateInput, NpiProviderUncheckedCreateInput>
    /**
     * In case the NpiProvider was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NpiProviderUpdateInput, NpiProviderUncheckedUpdateInput>
  }

  /**
   * NpiProvider delete
   */
  export type NpiProviderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    /**
     * Filter which NpiProvider to delete.
     */
    where: NpiProviderWhereUniqueInput
  }

  /**
   * NpiProvider deleteMany
   */
  export type NpiProviderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NpiProviders to delete
     */
    where?: NpiProviderWhereInput
    /**
     * Limit how many NpiProviders to delete.
     */
    limit?: number
  }

  /**
   * NpiProvider.claims
   */
  export type NpiProvider$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    cursor?: ClaimWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
  }

  /**
   * NpiProvider.payments
   */
  export type NpiProvider$paymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    cursor?: PaymentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * NpiProvider.commissionBatches
   */
  export type NpiProvider$commissionBatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    where?: CommissionBatchWhereInput
    orderBy?: CommissionBatchOrderByWithRelationInput | CommissionBatchOrderByWithRelationInput[]
    cursor?: CommissionBatchWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommissionBatchScalarFieldEnum | CommissionBatchScalarFieldEnum[]
  }

  /**
   * NpiProvider.appointmentProcedures
   */
  export type NpiProvider$appointmentProceduresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    where?: AppointmentProcedureWhereInput
    orderBy?: AppointmentProcedureOrderByWithRelationInput | AppointmentProcedureOrderByWithRelationInput[]
    cursor?: AppointmentProcedureWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentProcedureScalarFieldEnum | AppointmentProcedureScalarFieldEnum[]
  }

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


  /**
   * Model AppointmentProcedure
   */

  export type AggregateAppointmentProcedure = {
    _count: AppointmentProcedureCountAggregateOutputType | null
    _avg: AppointmentProcedureAvgAggregateOutputType | null
    _sum: AppointmentProcedureSumAggregateOutputType | null
    _min: AppointmentProcedureMinAggregateOutputType | null
    _max: AppointmentProcedureMaxAggregateOutputType | null
  }

  export type AppointmentProcedureAvgAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    patientId: number | null
    npiProviderId: number | null
    fee: Decimal | null
  }

  export type AppointmentProcedureSumAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    patientId: number | null
    npiProviderId: number | null
    fee: Decimal | null
  }

  export type AppointmentProcedureMinAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    patientId: number | null
    npiProviderId: number | null
    procedureCode: string | null
    procedureLabel: string | null
    fee: Decimal | null
    category: string | null
    toothNumber: string | null
    toothSurface: string | null
    oralCavityArea: string | null
    source: $Enums.ProcedureSource | null
    comboKey: string | null
    createdAt: Date | null
  }

  export type AppointmentProcedureMaxAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    patientId: number | null
    npiProviderId: number | null
    procedureCode: string | null
    procedureLabel: string | null
    fee: Decimal | null
    category: string | null
    toothNumber: string | null
    toothSurface: string | null
    oralCavityArea: string | null
    source: $Enums.ProcedureSource | null
    comboKey: string | null
    createdAt: Date | null
  }

  export type AppointmentProcedureCountAggregateOutputType = {
    id: number
    appointmentId: number
    patientId: number
    npiProviderId: number
    procedureCode: number
    procedureLabel: number
    fee: number
    category: number
    toothNumber: number
    toothSurface: number
    oralCavityArea: number
    source: number
    comboKey: number
    createdAt: number
    _all: number
  }


  export type AppointmentProcedureAvgAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: true
    npiProviderId?: true
    fee?: true
  }

  export type AppointmentProcedureSumAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: true
    npiProviderId?: true
    fee?: true
  }

  export type AppointmentProcedureMinAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: true
    npiProviderId?: true
    procedureCode?: true
    procedureLabel?: true
    fee?: true
    category?: true
    toothNumber?: true
    toothSurface?: true
    oralCavityArea?: true
    source?: true
    comboKey?: true
    createdAt?: true
  }

  export type AppointmentProcedureMaxAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: true
    npiProviderId?: true
    procedureCode?: true
    procedureLabel?: true
    fee?: true
    category?: true
    toothNumber?: true
    toothSurface?: true
    oralCavityArea?: true
    source?: true
    comboKey?: true
    createdAt?: true
  }

  export type AppointmentProcedureCountAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: true
    npiProviderId?: true
    procedureCode?: true
    procedureLabel?: true
    fee?: true
    category?: true
    toothNumber?: true
    toothSurface?: true
    oralCavityArea?: true
    source?: true
    comboKey?: true
    createdAt?: true
    _all?: true
  }

  export type AppointmentProcedureAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentProcedure to aggregate.
     */
    where?: AppointmentProcedureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AppointmentProcedures to fetch.
     */
    orderBy?: AppointmentProcedureOrderByWithRelationInput | AppointmentProcedureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AppointmentProcedureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AppointmentProcedures 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` AppointmentProcedures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AppointmentProcedures
    **/
    _count?: true | AppointmentProcedureCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AppointmentProcedureAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AppointmentProcedureSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AppointmentProcedureMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AppointmentProcedureMaxAggregateInputType
  }

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




  export type AppointmentProcedureGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentProcedureWhereInput
    orderBy?: AppointmentProcedureOrderByWithAggregationInput | AppointmentProcedureOrderByWithAggregationInput[]
    by: AppointmentProcedureScalarFieldEnum[] | AppointmentProcedureScalarFieldEnum
    having?: AppointmentProcedureScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentProcedureCountAggregateInputType | true
    _avg?: AppointmentProcedureAvgAggregateInputType
    _sum?: AppointmentProcedureSumAggregateInputType
    _min?: AppointmentProcedureMinAggregateInputType
    _max?: AppointmentProcedureMaxAggregateInputType
  }

  export type AppointmentProcedureGroupByOutputType = {
    id: number
    appointmentId: number
    patientId: number
    npiProviderId: number | null
    procedureCode: string
    procedureLabel: string | null
    fee: Decimal | null
    category: string | null
    toothNumber: string | null
    toothSurface: string | null
    oralCavityArea: string | null
    source: $Enums.ProcedureSource
    comboKey: string | null
    createdAt: Date
    _count: AppointmentProcedureCountAggregateOutputType | null
    _avg: AppointmentProcedureAvgAggregateOutputType | null
    _sum: AppointmentProcedureSumAggregateOutputType | null
    _min: AppointmentProcedureMinAggregateOutputType | null
    _max: AppointmentProcedureMaxAggregateOutputType | null
  }

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


  export type AppointmentProcedureSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    patientId?: boolean
    npiProviderId?: boolean
    procedureCode?: boolean
    procedureLabel?: boolean
    fee?: boolean
    category?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    oralCavityArea?: boolean
    source?: boolean
    comboKey?: boolean
    createdAt?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    patientId?: boolean
    npiProviderId?: boolean
    procedureCode?: boolean
    procedureLabel?: boolean
    fee?: boolean
    category?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    oralCavityArea?: boolean
    source?: boolean
    comboKey?: boolean
    createdAt?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    patientId?: boolean
    npiProviderId?: boolean
    procedureCode?: boolean
    procedureLabel?: boolean
    fee?: boolean
    category?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    oralCavityArea?: boolean
    source?: boolean
    comboKey?: boolean
    createdAt?: boolean
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectScalar = {
    id?: boolean
    appointmentId?: boolean
    patientId?: boolean
    npiProviderId?: boolean
    procedureCode?: boolean
    procedureLabel?: boolean
    fee?: boolean
    category?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    oralCavityArea?: boolean
    source?: boolean
    comboKey?: boolean
    createdAt?: boolean
  }

  export type AppointmentProcedureOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "appointmentId" | "patientId" | "npiProviderId" | "procedureCode" | "procedureLabel" | "fee" | "category" | "toothNumber" | "toothSurface" | "oralCavityArea" | "source" | "comboKey" | "createdAt", ExtArgs["result"]["appointmentProcedure"]>
  export type AppointmentProcedureInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }
  export type AppointmentProcedureIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }
  export type AppointmentProcedureIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    npiProvider?: boolean | AppointmentProcedure$npiProviderArgs<ExtArgs>
  }

  export type $AppointmentProcedurePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentProcedure"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      patient: Prisma.$PatientPayload<ExtArgs>
      npiProvider: Prisma.$NpiProviderPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      appointmentId: number
      patientId: number
      npiProviderId: number | null
      procedureCode: string
      procedureLabel: string | null
      fee: Prisma.Decimal | null
      category: string | null
      toothNumber: string | null
      toothSurface: string | null
      oralCavityArea: string | null
      source: $Enums.ProcedureSource
      comboKey: string | null
      createdAt: Date
    }, ExtArgs["result"]["appointmentProcedure"]>
    composites: {}
  }

  type AppointmentProcedureGetPayload<S extends boolean | null | undefined | AppointmentProcedureDefaultArgs> = $Result.GetResult<Prisma.$AppointmentProcedurePayload, S>

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

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

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

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

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

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

    /**
     * Create a AppointmentProcedure.
     * @param {AppointmentProcedureCreateArgs} args - Arguments to create a AppointmentProcedure.
     * @example
     * // Create one AppointmentProcedure
     * const AppointmentProcedure = await prisma.appointmentProcedure.create({
     *   data: {
     *     // ... data to create a AppointmentProcedure
     *   }
     * })
     * 
     */
    create<T extends AppointmentProcedureCreateArgs>(args: SelectSubset<T, AppointmentProcedureCreateArgs<ExtArgs>>): Prisma__AppointmentProcedureClient<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AppointmentProcedures and returns the data saved in the database.
     * @param {AppointmentProcedureCreateManyAndReturnArgs} args - Arguments to create many AppointmentProcedures.
     * @example
     * // Create many AppointmentProcedures
     * const appointmentProcedure = await prisma.appointmentProcedure.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AppointmentProcedures and only return the `id`
     * const appointmentProcedureWithIdOnly = await prisma.appointmentProcedure.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 AppointmentProcedureCreateManyAndReturnArgs>(args?: SelectSubset<T, AppointmentProcedureCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AppointmentProcedure.
     * @param {AppointmentProcedureDeleteArgs} args - Arguments to delete one AppointmentProcedure.
     * @example
     * // Delete one AppointmentProcedure
     * const AppointmentProcedure = await prisma.appointmentProcedure.delete({
     *   where: {
     *     // ... filter to delete one AppointmentProcedure
     *   }
     * })
     * 
     */
    delete<T extends AppointmentProcedureDeleteArgs>(args: SelectSubset<T, AppointmentProcedureDeleteArgs<ExtArgs>>): Prisma__AppointmentProcedureClient<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more AppointmentProcedures and returns the data updated in the database.
     * @param {AppointmentProcedureUpdateManyAndReturnArgs} args - Arguments to update many AppointmentProcedures.
     * @example
     * // Update many AppointmentProcedures
     * const appointmentProcedure = await prisma.appointmentProcedure.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AppointmentProcedures and only return the `id`
     * const appointmentProcedureWithIdOnly = await prisma.appointmentProcedure.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AppointmentProcedureUpdateManyAndReturnArgs>(args: SelectSubset<T, AppointmentProcedureUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentProcedurePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppointmentProcedure.
   * 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__AppointmentProcedureClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> 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", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    npiProvider<T extends AppointmentProcedure$npiProviderArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentProcedure$npiProviderArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the AppointmentProcedure model
   */
  interface AppointmentProcedureFieldRefs {
    readonly id: FieldRef<"AppointmentProcedure", 'Int'>
    readonly appointmentId: FieldRef<"AppointmentProcedure", 'Int'>
    readonly patientId: FieldRef<"AppointmentProcedure", 'Int'>
    readonly npiProviderId: FieldRef<"AppointmentProcedure", 'Int'>
    readonly procedureCode: FieldRef<"AppointmentProcedure", 'String'>
    readonly procedureLabel: FieldRef<"AppointmentProcedure", 'String'>
    readonly fee: FieldRef<"AppointmentProcedure", 'Decimal'>
    readonly category: FieldRef<"AppointmentProcedure", 'String'>
    readonly toothNumber: FieldRef<"AppointmentProcedure", 'String'>
    readonly toothSurface: FieldRef<"AppointmentProcedure", 'String'>
    readonly oralCavityArea: FieldRef<"AppointmentProcedure", 'String'>
    readonly source: FieldRef<"AppointmentProcedure", 'ProcedureSource'>
    readonly comboKey: FieldRef<"AppointmentProcedure", 'String'>
    readonly createdAt: FieldRef<"AppointmentProcedure", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * AppointmentProcedure findUnique
   */
  export type AppointmentProcedureFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentProcedure to fetch.
     */
    where: AppointmentProcedureWhereUniqueInput
  }

  /**
   * AppointmentProcedure findUniqueOrThrow
   */
  export type AppointmentProcedureFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentProcedure to fetch.
     */
    where: AppointmentProcedureWhereUniqueInput
  }

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

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

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

  /**
   * AppointmentProcedure create
   */
  export type AppointmentProcedureCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * The data needed to create a AppointmentProcedure.
     */
    data: XOR<AppointmentProcedureCreateInput, AppointmentProcedureUncheckedCreateInput>
  }

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

  /**
   * AppointmentProcedure createManyAndReturn
   */
  export type AppointmentProcedureCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * The data used to create many AppointmentProcedures.
     */
    data: AppointmentProcedureCreateManyInput | AppointmentProcedureCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AppointmentProcedure update
   */
  export type AppointmentProcedureUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * The data needed to update a AppointmentProcedure.
     */
    data: XOR<AppointmentProcedureUpdateInput, AppointmentProcedureUncheckedUpdateInput>
    /**
     * Choose, which AppointmentProcedure to update.
     */
    where: AppointmentProcedureWhereUniqueInput
  }

  /**
   * AppointmentProcedure updateMany
   */
  export type AppointmentProcedureUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppointmentProcedures.
     */
    data: XOR<AppointmentProcedureUpdateManyMutationInput, AppointmentProcedureUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentProcedures to update
     */
    where?: AppointmentProcedureWhereInput
    /**
     * Limit how many AppointmentProcedures to update.
     */
    limit?: number
  }

  /**
   * AppointmentProcedure updateManyAndReturn
   */
  export type AppointmentProcedureUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * The data used to update AppointmentProcedures.
     */
    data: XOR<AppointmentProcedureUpdateManyMutationInput, AppointmentProcedureUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentProcedures to update
     */
    where?: AppointmentProcedureWhereInput
    /**
     * Limit how many AppointmentProcedures to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * AppointmentProcedure upsert
   */
  export type AppointmentProcedureUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * The filter to search for the AppointmentProcedure to update in case it exists.
     */
    where: AppointmentProcedureWhereUniqueInput
    /**
     * In case the AppointmentProcedure found by the `where` argument doesn't exist, create a new AppointmentProcedure with this data.
     */
    create: XOR<AppointmentProcedureCreateInput, AppointmentProcedureUncheckedCreateInput>
    /**
     * In case the AppointmentProcedure was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentProcedureUpdateInput, AppointmentProcedureUncheckedUpdateInput>
  }

  /**
   * AppointmentProcedure delete
   */
  export type AppointmentProcedureDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentProcedure
     */
    select?: AppointmentProcedureSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AppointmentProcedure
     */
    omit?: AppointmentProcedureOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentProcedureInclude<ExtArgs> | null
    /**
     * Filter which AppointmentProcedure to delete.
     */
    where: AppointmentProcedureWhereUniqueInput
  }

  /**
   * AppointmentProcedure deleteMany
   */
  export type AppointmentProcedureDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentProcedures to delete
     */
    where?: AppointmentProcedureWhereInput
    /**
     * Limit how many AppointmentProcedures to delete.
     */
    limit?: number
  }

  /**
   * AppointmentProcedure.npiProvider
   */
  export type AppointmentProcedure$npiProviderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    where?: NpiProviderWhereInput
  }

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


  /**
   * Model Claim
   */

  export type AggregateClaim = {
    _count: ClaimCountAggregateOutputType | null
    _avg: ClaimAvgAggregateOutputType | null
    _sum: ClaimSumAggregateOutputType | null
    _min: ClaimMinAggregateOutputType | null
    _max: ClaimMaxAggregateOutputType | null
  }

  export type ClaimAvgAggregateOutputType = {
    id: number | null
    patientId: number | null
    appointmentId: number | null
    userId: number | null
    staffId: number | null
    npiProviderId: number | null
  }

  export type ClaimSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    appointmentId: number | null
    userId: number | null
    staffId: number | null
    npiProviderId: number | null
  }

  export type ClaimMinAggregateOutputType = {
    id: number | null
    patientId: number | null
    appointmentId: number | null
    userId: number | null
    staffId: number | null
    patientName: string | null
    memberId: string | null
    dateOfBirth: Date | null
    remarks: string | null
    missingTeethStatus: $Enums.MissingTeethStatus | null
    serviceDate: Date | null
    insuranceProvider: string | null
    createdAt: Date | null
    updatedAt: Date | null
    status: $Enums.ClaimStatus | null
    claimNumber: string | null
    preAuthNumber: string | null
    npiProviderId: number | null
  }

  export type ClaimMaxAggregateOutputType = {
    id: number | null
    patientId: number | null
    appointmentId: number | null
    userId: number | null
    staffId: number | null
    patientName: string | null
    memberId: string | null
    dateOfBirth: Date | null
    remarks: string | null
    missingTeethStatus: $Enums.MissingTeethStatus | null
    serviceDate: Date | null
    insuranceProvider: string | null
    createdAt: Date | null
    updatedAt: Date | null
    status: $Enums.ClaimStatus | null
    claimNumber: string | null
    preAuthNumber: string | null
    npiProviderId: number | null
  }

  export type ClaimCountAggregateOutputType = {
    id: number
    patientId: number
    appointmentId: number
    userId: number
    staffId: number
    patientName: number
    memberId: number
    dateOfBirth: number
    remarks: number
    missingTeethStatus: number
    missingTeeth: number
    serviceDate: number
    insuranceProvider: number
    createdAt: number
    updatedAt: number
    status: number
    claimNumber: number
    preAuthNumber: number
    npiProviderId: number
    _all: number
  }


  export type ClaimAvgAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: true
    npiProviderId?: true
  }

  export type ClaimSumAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: true
    npiProviderId?: true
  }

  export type ClaimMinAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: true
    patientName?: true
    memberId?: true
    dateOfBirth?: true
    remarks?: true
    missingTeethStatus?: true
    serviceDate?: true
    insuranceProvider?: true
    createdAt?: true
    updatedAt?: true
    status?: true
    claimNumber?: true
    preAuthNumber?: true
    npiProviderId?: true
  }

  export type ClaimMaxAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: true
    patientName?: true
    memberId?: true
    dateOfBirth?: true
    remarks?: true
    missingTeethStatus?: true
    serviceDate?: true
    insuranceProvider?: true
    createdAt?: true
    updatedAt?: true
    status?: true
    claimNumber?: true
    preAuthNumber?: true
    npiProviderId?: true
  }

  export type ClaimCountAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: true
    patientName?: true
    memberId?: true
    dateOfBirth?: true
    remarks?: true
    missingTeethStatus?: true
    missingTeeth?: true
    serviceDate?: true
    insuranceProvider?: true
    createdAt?: true
    updatedAt?: true
    status?: true
    claimNumber?: true
    preAuthNumber?: true
    npiProviderId?: true
    _all?: true
  }

  export type ClaimAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Claim to aggregate.
     */
    where?: ClaimWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Claims to fetch.
     */
    orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ClaimWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Claims 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` Claims.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Claims
    **/
    _count?: true | ClaimCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ClaimAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ClaimSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ClaimMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ClaimMaxAggregateInputType
  }

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




  export type ClaimGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimWhereInput
    orderBy?: ClaimOrderByWithAggregationInput | ClaimOrderByWithAggregationInput[]
    by: ClaimScalarFieldEnum[] | ClaimScalarFieldEnum
    having?: ClaimScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ClaimCountAggregateInputType | true
    _avg?: ClaimAvgAggregateInputType
    _sum?: ClaimSumAggregateInputType
    _min?: ClaimMinAggregateInputType
    _max?: ClaimMaxAggregateInputType
  }

  export type ClaimGroupByOutputType = {
    id: number
    patientId: number
    appointmentId: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date
    remarks: string
    missingTeethStatus: $Enums.MissingTeethStatus
    missingTeeth: JsonValue | null
    serviceDate: Date
    insuranceProvider: string
    createdAt: Date
    updatedAt: Date
    status: $Enums.ClaimStatus
    claimNumber: string | null
    preAuthNumber: string | null
    npiProviderId: number | null
    _count: ClaimCountAggregateOutputType | null
    _avg: ClaimAvgAggregateOutputType | null
    _sum: ClaimSumAggregateOutputType | null
    _min: ClaimMinAggregateOutputType | null
    _max: ClaimMaxAggregateOutputType | null
  }

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


  export type ClaimSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    appointmentId?: boolean
    userId?: boolean
    staffId?: boolean
    patientName?: boolean
    memberId?: boolean
    dateOfBirth?: boolean
    remarks?: boolean
    missingTeethStatus?: boolean
    missingTeeth?: boolean
    serviceDate?: boolean
    insuranceProvider?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    status?: boolean
    claimNumber?: boolean
    preAuthNumber?: boolean
    npiProviderId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
    serviceLines?: boolean | Claim$serviceLinesArgs<ExtArgs>
    claimFiles?: boolean | Claim$claimFilesArgs<ExtArgs>
    payment?: boolean | Claim$paymentArgs<ExtArgs>
    _count?: boolean | ClaimCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["claim"]>

  export type ClaimSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    appointmentId?: boolean
    userId?: boolean
    staffId?: boolean
    patientName?: boolean
    memberId?: boolean
    dateOfBirth?: boolean
    remarks?: boolean
    missingTeethStatus?: boolean
    missingTeeth?: boolean
    serviceDate?: boolean
    insuranceProvider?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    status?: boolean
    claimNumber?: boolean
    preAuthNumber?: boolean
    npiProviderId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["claim"]>

  export type ClaimSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    appointmentId?: boolean
    userId?: boolean
    staffId?: boolean
    patientName?: boolean
    memberId?: boolean
    dateOfBirth?: boolean
    remarks?: boolean
    missingTeethStatus?: boolean
    missingTeeth?: boolean
    serviceDate?: boolean
    insuranceProvider?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    status?: boolean
    claimNumber?: boolean
    preAuthNumber?: boolean
    npiProviderId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["claim"]>

  export type ClaimSelectScalar = {
    id?: boolean
    patientId?: boolean
    appointmentId?: boolean
    userId?: boolean
    staffId?: boolean
    patientName?: boolean
    memberId?: boolean
    dateOfBirth?: boolean
    remarks?: boolean
    missingTeethStatus?: boolean
    missingTeeth?: boolean
    serviceDate?: boolean
    insuranceProvider?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    status?: boolean
    claimNumber?: boolean
    preAuthNumber?: boolean
    npiProviderId?: boolean
  }

  export type ClaimOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "patientId" | "appointmentId" | "userId" | "staffId" | "patientName" | "memberId" | "dateOfBirth" | "remarks" | "missingTeethStatus" | "missingTeeth" | "serviceDate" | "insuranceProvider" | "createdAt" | "updatedAt" | "status" | "claimNumber" | "preAuthNumber" | "npiProviderId", ExtArgs["result"]["claim"]>
  export type ClaimInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
    serviceLines?: boolean | Claim$serviceLinesArgs<ExtArgs>
    claimFiles?: boolean | Claim$claimFilesArgs<ExtArgs>
    payment?: boolean | Claim$paymentArgs<ExtArgs>
    _count?: boolean | ClaimCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ClaimIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
  }
  export type ClaimIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | Claim$appointmentArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
    npiProvider?: boolean | Claim$npiProviderArgs<ExtArgs>
  }

  export type $ClaimPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Claim"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      appointment: Prisma.$AppointmentPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs> | null
      staff: Prisma.$StaffPayload<ExtArgs> | null
      npiProvider: Prisma.$NpiProviderPayload<ExtArgs> | null
      serviceLines: Prisma.$ServiceLinePayload<ExtArgs>[]
      claimFiles: Prisma.$ClaimFilePayload<ExtArgs>[]
      payment: Prisma.$PaymentPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      appointmentId: number | null
      userId: number
      staffId: number
      patientName: string
      memberId: string
      dateOfBirth: Date
      remarks: string
      missingTeethStatus: $Enums.MissingTeethStatus
      missingTeeth: Prisma.JsonValue | null
      serviceDate: Date
      insuranceProvider: string
      createdAt: Date
      updatedAt: Date
      status: $Enums.ClaimStatus
      claimNumber: string | null
      preAuthNumber: string | null
      npiProviderId: number | null
    }, ExtArgs["result"]["claim"]>
    composites: {}
  }

  type ClaimGetPayload<S extends boolean | null | undefined | ClaimDefaultArgs> = $Result.GetResult<Prisma.$ClaimPayload, S>

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

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

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

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

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

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

    /**
     * Create a Claim.
     * @param {ClaimCreateArgs} args - Arguments to create a Claim.
     * @example
     * // Create one Claim
     * const Claim = await prisma.claim.create({
     *   data: {
     *     // ... data to create a Claim
     *   }
     * })
     * 
     */
    create<T extends ClaimCreateArgs>(args: SelectSubset<T, ClaimCreateArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Claims and returns the data saved in the database.
     * @param {ClaimCreateManyAndReturnArgs} args - Arguments to create many Claims.
     * @example
     * // Create many Claims
     * const claim = await prisma.claim.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Claims and only return the `id`
     * const claimWithIdOnly = await prisma.claim.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 ClaimCreateManyAndReturnArgs>(args?: SelectSubset<T, ClaimCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Claim.
     * @param {ClaimDeleteArgs} args - Arguments to delete one Claim.
     * @example
     * // Delete one Claim
     * const Claim = await prisma.claim.delete({
     *   where: {
     *     // ... filter to delete one Claim
     *   }
     * })
     * 
     */
    delete<T extends ClaimDeleteArgs>(args: SelectSubset<T, ClaimDeleteArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more Claims and returns the data updated in the database.
     * @param {ClaimUpdateManyAndReturnArgs} args - Arguments to update many Claims.
     * @example
     * // Update many Claims
     * const claim = await prisma.claim.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Claims and only return the `id`
     * const claimWithIdOnly = await prisma.claim.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ClaimUpdateManyAndReturnArgs>(args: SelectSubset<T, ClaimUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Claim.
   * 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__ClaimClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    appointment<T extends Claim$appointmentArgs<ExtArgs> = {}>(args?: Subset<T, Claim$appointmentArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    user<T extends Claim$userArgs<ExtArgs> = {}>(args?: Subset<T, Claim$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    staff<T extends Claim$staffArgs<ExtArgs> = {}>(args?: Subset<T, Claim$staffArgs<ExtArgs>>): Prisma__StaffClient<$Result.GetResult<Prisma.$StaffPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    npiProvider<T extends Claim$npiProviderArgs<ExtArgs> = {}>(args?: Subset<T, Claim$npiProviderArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    serviceLines<T extends Claim$serviceLinesArgs<ExtArgs> = {}>(args?: Subset<T, Claim$serviceLinesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    claimFiles<T extends Claim$claimFilesArgs<ExtArgs> = {}>(args?: Subset<T, Claim$claimFilesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimFilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    payment<T extends Claim$paymentArgs<ExtArgs> = {}>(args?: Subset<T, Claim$paymentArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Claim model
   */
  interface ClaimFieldRefs {
    readonly id: FieldRef<"Claim", 'Int'>
    readonly patientId: FieldRef<"Claim", 'Int'>
    readonly appointmentId: FieldRef<"Claim", 'Int'>
    readonly userId: FieldRef<"Claim", 'Int'>
    readonly staffId: FieldRef<"Claim", 'Int'>
    readonly patientName: FieldRef<"Claim", 'String'>
    readonly memberId: FieldRef<"Claim", 'String'>
    readonly dateOfBirth: FieldRef<"Claim", 'DateTime'>
    readonly remarks: FieldRef<"Claim", 'String'>
    readonly missingTeethStatus: FieldRef<"Claim", 'MissingTeethStatus'>
    readonly missingTeeth: FieldRef<"Claim", 'Json'>
    readonly serviceDate: FieldRef<"Claim", 'DateTime'>
    readonly insuranceProvider: FieldRef<"Claim", 'String'>
    readonly createdAt: FieldRef<"Claim", 'DateTime'>
    readonly updatedAt: FieldRef<"Claim", 'DateTime'>
    readonly status: FieldRef<"Claim", 'ClaimStatus'>
    readonly claimNumber: FieldRef<"Claim", 'String'>
    readonly preAuthNumber: FieldRef<"Claim", 'String'>
    readonly npiProviderId: FieldRef<"Claim", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * Claim findUnique
   */
  export type ClaimFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * Filter, which Claim to fetch.
     */
    where: ClaimWhereUniqueInput
  }

  /**
   * Claim findUniqueOrThrow
   */
  export type ClaimFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * Filter, which Claim to fetch.
     */
    where: ClaimWhereUniqueInput
  }

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

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

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

  /**
   * Claim create
   */
  export type ClaimCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * The data needed to create a Claim.
     */
    data: XOR<ClaimCreateInput, ClaimUncheckedCreateInput>
  }

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

  /**
   * Claim createManyAndReturn
   */
  export type ClaimCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * The data used to create many Claims.
     */
    data: ClaimCreateManyInput | ClaimCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Claim update
   */
  export type ClaimUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * The data needed to update a Claim.
     */
    data: XOR<ClaimUpdateInput, ClaimUncheckedUpdateInput>
    /**
     * Choose, which Claim to update.
     */
    where: ClaimWhereUniqueInput
  }

  /**
   * Claim updateMany
   */
  export type ClaimUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Claims.
     */
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyInput>
    /**
     * Filter which Claims to update
     */
    where?: ClaimWhereInput
    /**
     * Limit how many Claims to update.
     */
    limit?: number
  }

  /**
   * Claim updateManyAndReturn
   */
  export type ClaimUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * The data used to update Claims.
     */
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyInput>
    /**
     * Filter which Claims to update
     */
    where?: ClaimWhereInput
    /**
     * Limit how many Claims to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Claim upsert
   */
  export type ClaimUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * The filter to search for the Claim to update in case it exists.
     */
    where: ClaimWhereUniqueInput
    /**
     * In case the Claim found by the `where` argument doesn't exist, create a new Claim with this data.
     */
    create: XOR<ClaimCreateInput, ClaimUncheckedCreateInput>
    /**
     * In case the Claim was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ClaimUpdateInput, ClaimUncheckedUpdateInput>
  }

  /**
   * Claim delete
   */
  export type ClaimDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    /**
     * Filter which Claim to delete.
     */
    where: ClaimWhereUniqueInput
  }

  /**
   * Claim deleteMany
   */
  export type ClaimDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Claims to delete
     */
    where?: ClaimWhereInput
    /**
     * Limit how many Claims to delete.
     */
    limit?: number
  }

  /**
   * Claim.appointment
   */
  export type Claim$appointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    where?: AppointmentWhereInput
  }

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

  /**
   * Claim.staff
   */
  export type Claim$staffArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Staff
     */
    select?: StaffSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Staff
     */
    omit?: StaffOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: StaffInclude<ExtArgs> | null
    where?: StaffWhereInput
  }

  /**
   * Claim.npiProvider
   */
  export type Claim$npiProviderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    where?: NpiProviderWhereInput
  }

  /**
   * Claim.serviceLines
   */
  export type Claim$serviceLinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    where?: ServiceLineWhereInput
    orderBy?: ServiceLineOrderByWithRelationInput | ServiceLineOrderByWithRelationInput[]
    cursor?: ServiceLineWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ServiceLineScalarFieldEnum | ServiceLineScalarFieldEnum[]
  }

  /**
   * Claim.claimFiles
   */
  export type Claim$claimFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    where?: ClaimFileWhereInput
    orderBy?: ClaimFileOrderByWithRelationInput | ClaimFileOrderByWithRelationInput[]
    cursor?: ClaimFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClaimFileScalarFieldEnum | ClaimFileScalarFieldEnum[]
  }

  /**
   * Claim.payment
   */
  export type Claim$paymentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
  }

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


  /**
   * Model ServiceLine
   */

  export type AggregateServiceLine = {
    _count: ServiceLineCountAggregateOutputType | null
    _avg: ServiceLineAvgAggregateOutputType | null
    _sum: ServiceLineSumAggregateOutputType | null
    _min: ServiceLineMinAggregateOutputType | null
    _max: ServiceLineMaxAggregateOutputType | null
  }

  export type ServiceLineAvgAggregateOutputType = {
    id: number | null
    claimId: number | null
    paymentId: number | null
    allowedAmount: Decimal | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
  }

  export type ServiceLineSumAggregateOutputType = {
    id: number | null
    claimId: number | null
    paymentId: number | null
    allowedAmount: Decimal | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
  }

  export type ServiceLineMinAggregateOutputType = {
    id: number | null
    claimId: number | null
    paymentId: number | null
    procedureCode: string | null
    procedureDate: Date | null
    quad: string | null
    arch: string | null
    toothNumber: string | null
    toothSurface: string | null
    icn: string | null
    paidCode: string | null
    allowedAmount: Decimal | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    status: $Enums.ServiceLineStatus | null
  }

  export type ServiceLineMaxAggregateOutputType = {
    id: number | null
    claimId: number | null
    paymentId: number | null
    procedureCode: string | null
    procedureDate: Date | null
    quad: string | null
    arch: string | null
    toothNumber: string | null
    toothSurface: string | null
    icn: string | null
    paidCode: string | null
    allowedAmount: Decimal | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    status: $Enums.ServiceLineStatus | null
  }

  export type ServiceLineCountAggregateOutputType = {
    id: number
    claimId: number
    paymentId: number
    procedureCode: number
    procedureDate: number
    quad: number
    arch: number
    toothNumber: number
    toothSurface: number
    icn: number
    paidCode: number
    allowedAmount: number
    totalBilled: number
    totalPaid: number
    totalAdjusted: number
    totalDue: number
    status: number
    _all: number
  }


  export type ServiceLineAvgAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: true
    allowedAmount?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
  }

  export type ServiceLineSumAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: true
    allowedAmount?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
  }

  export type ServiceLineMinAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: true
    procedureCode?: true
    procedureDate?: true
    quad?: true
    arch?: true
    toothNumber?: true
    toothSurface?: true
    icn?: true
    paidCode?: true
    allowedAmount?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    status?: true
  }

  export type ServiceLineMaxAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: true
    procedureCode?: true
    procedureDate?: true
    quad?: true
    arch?: true
    toothNumber?: true
    toothSurface?: true
    icn?: true
    paidCode?: true
    allowedAmount?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    status?: true
  }

  export type ServiceLineCountAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: true
    procedureCode?: true
    procedureDate?: true
    quad?: true
    arch?: true
    toothNumber?: true
    toothSurface?: true
    icn?: true
    paidCode?: true
    allowedAmount?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    status?: true
    _all?: true
  }

  export type ServiceLineAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ServiceLine to aggregate.
     */
    where?: ServiceLineWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ServiceLines to fetch.
     */
    orderBy?: ServiceLineOrderByWithRelationInput | ServiceLineOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ServiceLineWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ServiceLines 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` ServiceLines.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ServiceLines
    **/
    _count?: true | ServiceLineCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ServiceLineAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ServiceLineSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ServiceLineMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ServiceLineMaxAggregateInputType
  }

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




  export type ServiceLineGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineWhereInput
    orderBy?: ServiceLineOrderByWithAggregationInput | ServiceLineOrderByWithAggregationInput[]
    by: ServiceLineScalarFieldEnum[] | ServiceLineScalarFieldEnum
    having?: ServiceLineScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ServiceLineCountAggregateInputType | true
    _avg?: ServiceLineAvgAggregateInputType
    _sum?: ServiceLineSumAggregateInputType
    _min?: ServiceLineMinAggregateInputType
    _max?: ServiceLineMaxAggregateInputType
  }

  export type ServiceLineGroupByOutputType = {
    id: number
    claimId: number | null
    paymentId: number | null
    procedureCode: string
    procedureDate: Date
    quad: string | null
    arch: string | null
    toothNumber: string | null
    toothSurface: string | null
    icn: string | null
    paidCode: string | null
    allowedAmount: Decimal | null
    totalBilled: Decimal
    totalPaid: Decimal
    totalAdjusted: Decimal
    totalDue: Decimal
    status: $Enums.ServiceLineStatus
    _count: ServiceLineCountAggregateOutputType | null
    _avg: ServiceLineAvgAggregateOutputType | null
    _sum: ServiceLineSumAggregateOutputType | null
    _min: ServiceLineMinAggregateOutputType | null
    _max: ServiceLineMaxAggregateOutputType | null
  }

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


  export type ServiceLineSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    paymentId?: boolean
    procedureCode?: boolean
    procedureDate?: boolean
    quad?: boolean
    arch?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    icn?: boolean
    paidCode?: boolean
    allowedAmount?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    status?: boolean
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
    serviceLineTransactions?: boolean | ServiceLine$serviceLineTransactionsArgs<ExtArgs>
    _count?: boolean | ServiceLineCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLine"]>

  export type ServiceLineSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    paymentId?: boolean
    procedureCode?: boolean
    procedureDate?: boolean
    quad?: boolean
    arch?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    icn?: boolean
    paidCode?: boolean
    allowedAmount?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    status?: boolean
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLine"]>

  export type ServiceLineSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    paymentId?: boolean
    procedureCode?: boolean
    procedureDate?: boolean
    quad?: boolean
    arch?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    icn?: boolean
    paidCode?: boolean
    allowedAmount?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    status?: boolean
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLine"]>

  export type ServiceLineSelectScalar = {
    id?: boolean
    claimId?: boolean
    paymentId?: boolean
    procedureCode?: boolean
    procedureDate?: boolean
    quad?: boolean
    arch?: boolean
    toothNumber?: boolean
    toothSurface?: boolean
    icn?: boolean
    paidCode?: boolean
    allowedAmount?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    status?: boolean
  }

  export type ServiceLineOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "claimId" | "paymentId" | "procedureCode" | "procedureDate" | "quad" | "arch" | "toothNumber" | "toothSurface" | "icn" | "paidCode" | "allowedAmount" | "totalBilled" | "totalPaid" | "totalAdjusted" | "totalDue" | "status", ExtArgs["result"]["serviceLine"]>
  export type ServiceLineInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
    serviceLineTransactions?: boolean | ServiceLine$serviceLineTransactionsArgs<ExtArgs>
    _count?: boolean | ServiceLineCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ServiceLineIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
  }
  export type ServiceLineIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ServiceLine$claimArgs<ExtArgs>
    payment?: boolean | ServiceLine$paymentArgs<ExtArgs>
  }

  export type $ServiceLinePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ServiceLine"
    objects: {
      claim: Prisma.$ClaimPayload<ExtArgs> | null
      payment: Prisma.$PaymentPayload<ExtArgs> | null
      serviceLineTransactions: Prisma.$ServiceLineTransactionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      claimId: number | null
      paymentId: number | null
      procedureCode: string
      procedureDate: Date
      quad: string | null
      arch: string | null
      toothNumber: string | null
      toothSurface: string | null
      icn: string | null
      paidCode: string | null
      allowedAmount: Prisma.Decimal | null
      totalBilled: Prisma.Decimal
      totalPaid: Prisma.Decimal
      totalAdjusted: Prisma.Decimal
      totalDue: Prisma.Decimal
      status: $Enums.ServiceLineStatus
    }, ExtArgs["result"]["serviceLine"]>
    composites: {}
  }

  type ServiceLineGetPayload<S extends boolean | null | undefined | ServiceLineDefaultArgs> = $Result.GetResult<Prisma.$ServiceLinePayload, S>

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

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

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

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

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

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

    /**
     * Create a ServiceLine.
     * @param {ServiceLineCreateArgs} args - Arguments to create a ServiceLine.
     * @example
     * // Create one ServiceLine
     * const ServiceLine = await prisma.serviceLine.create({
     *   data: {
     *     // ... data to create a ServiceLine
     *   }
     * })
     * 
     */
    create<T extends ServiceLineCreateArgs>(args: SelectSubset<T, ServiceLineCreateArgs<ExtArgs>>): Prisma__ServiceLineClient<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ServiceLines and returns the data saved in the database.
     * @param {ServiceLineCreateManyAndReturnArgs} args - Arguments to create many ServiceLines.
     * @example
     * // Create many ServiceLines
     * const serviceLine = await prisma.serviceLine.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ServiceLines and only return the `id`
     * const serviceLineWithIdOnly = await prisma.serviceLine.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 ServiceLineCreateManyAndReturnArgs>(args?: SelectSubset<T, ServiceLineCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ServiceLine.
     * @param {ServiceLineDeleteArgs} args - Arguments to delete one ServiceLine.
     * @example
     * // Delete one ServiceLine
     * const ServiceLine = await prisma.serviceLine.delete({
     *   where: {
     *     // ... filter to delete one ServiceLine
     *   }
     * })
     * 
     */
    delete<T extends ServiceLineDeleteArgs>(args: SelectSubset<T, ServiceLineDeleteArgs<ExtArgs>>): Prisma__ServiceLineClient<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more ServiceLines and returns the data updated in the database.
     * @param {ServiceLineUpdateManyAndReturnArgs} args - Arguments to update many ServiceLines.
     * @example
     * // Update many ServiceLines
     * const serviceLine = await prisma.serviceLine.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ServiceLines and only return the `id`
     * const serviceLineWithIdOnly = await prisma.serviceLine.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ServiceLineUpdateManyAndReturnArgs>(args: SelectSubset<T, ServiceLineUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ServiceLine.
   * 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__ServiceLineClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    claim<T extends ServiceLine$claimArgs<ExtArgs> = {}>(args?: Subset<T, ServiceLine$claimArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    payment<T extends ServiceLine$paymentArgs<ExtArgs> = {}>(args?: Subset<T, ServiceLine$paymentArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    serviceLineTransactions<T extends ServiceLine$serviceLineTransactionsArgs<ExtArgs> = {}>(args?: Subset<T, ServiceLine$serviceLineTransactionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ServiceLine model
   */
  interface ServiceLineFieldRefs {
    readonly id: FieldRef<"ServiceLine", 'Int'>
    readonly claimId: FieldRef<"ServiceLine", 'Int'>
    readonly paymentId: FieldRef<"ServiceLine", 'Int'>
    readonly procedureCode: FieldRef<"ServiceLine", 'String'>
    readonly procedureDate: FieldRef<"ServiceLine", 'DateTime'>
    readonly quad: FieldRef<"ServiceLine", 'String'>
    readonly arch: FieldRef<"ServiceLine", 'String'>
    readonly toothNumber: FieldRef<"ServiceLine", 'String'>
    readonly toothSurface: FieldRef<"ServiceLine", 'String'>
    readonly icn: FieldRef<"ServiceLine", 'String'>
    readonly paidCode: FieldRef<"ServiceLine", 'String'>
    readonly allowedAmount: FieldRef<"ServiceLine", 'Decimal'>
    readonly totalBilled: FieldRef<"ServiceLine", 'Decimal'>
    readonly totalPaid: FieldRef<"ServiceLine", 'Decimal'>
    readonly totalAdjusted: FieldRef<"ServiceLine", 'Decimal'>
    readonly totalDue: FieldRef<"ServiceLine", 'Decimal'>
    readonly status: FieldRef<"ServiceLine", 'ServiceLineStatus'>
  }
    

  // Custom InputTypes
  /**
   * ServiceLine findUnique
   */
  export type ServiceLineFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * Filter, which ServiceLine to fetch.
     */
    where: ServiceLineWhereUniqueInput
  }

  /**
   * ServiceLine findUniqueOrThrow
   */
  export type ServiceLineFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * Filter, which ServiceLine to fetch.
     */
    where: ServiceLineWhereUniqueInput
  }

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

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

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

  /**
   * ServiceLine create
   */
  export type ServiceLineCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * The data needed to create a ServiceLine.
     */
    data: XOR<ServiceLineCreateInput, ServiceLineUncheckedCreateInput>
  }

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

  /**
   * ServiceLine createManyAndReturn
   */
  export type ServiceLineCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * The data used to create many ServiceLines.
     */
    data: ServiceLineCreateManyInput | ServiceLineCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ServiceLine update
   */
  export type ServiceLineUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * The data needed to update a ServiceLine.
     */
    data: XOR<ServiceLineUpdateInput, ServiceLineUncheckedUpdateInput>
    /**
     * Choose, which ServiceLine to update.
     */
    where: ServiceLineWhereUniqueInput
  }

  /**
   * ServiceLine updateMany
   */
  export type ServiceLineUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ServiceLines.
     */
    data: XOR<ServiceLineUpdateManyMutationInput, ServiceLineUncheckedUpdateManyInput>
    /**
     * Filter which ServiceLines to update
     */
    where?: ServiceLineWhereInput
    /**
     * Limit how many ServiceLines to update.
     */
    limit?: number
  }

  /**
   * ServiceLine updateManyAndReturn
   */
  export type ServiceLineUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * The data used to update ServiceLines.
     */
    data: XOR<ServiceLineUpdateManyMutationInput, ServiceLineUncheckedUpdateManyInput>
    /**
     * Filter which ServiceLines to update
     */
    where?: ServiceLineWhereInput
    /**
     * Limit how many ServiceLines to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ServiceLine upsert
   */
  export type ServiceLineUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * The filter to search for the ServiceLine to update in case it exists.
     */
    where: ServiceLineWhereUniqueInput
    /**
     * In case the ServiceLine found by the `where` argument doesn't exist, create a new ServiceLine with this data.
     */
    create: XOR<ServiceLineCreateInput, ServiceLineUncheckedCreateInput>
    /**
     * In case the ServiceLine was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ServiceLineUpdateInput, ServiceLineUncheckedUpdateInput>
  }

  /**
   * ServiceLine delete
   */
  export type ServiceLineDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    /**
     * Filter which ServiceLine to delete.
     */
    where: ServiceLineWhereUniqueInput
  }

  /**
   * ServiceLine deleteMany
   */
  export type ServiceLineDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ServiceLines to delete
     */
    where?: ServiceLineWhereInput
    /**
     * Limit how many ServiceLines to delete.
     */
    limit?: number
  }

  /**
   * ServiceLine.claim
   */
  export type ServiceLine$claimArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
  }

  /**
   * ServiceLine.payment
   */
  export type ServiceLine$paymentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
  }

  /**
   * ServiceLine.serviceLineTransactions
   */
  export type ServiceLine$serviceLineTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    where?: ServiceLineTransactionWhereInput
    orderBy?: ServiceLineTransactionOrderByWithRelationInput | ServiceLineTransactionOrderByWithRelationInput[]
    cursor?: ServiceLineTransactionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ServiceLineTransactionScalarFieldEnum | ServiceLineTransactionScalarFieldEnum[]
  }

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


  /**
   * Model ClaimFile
   */

  export type AggregateClaimFile = {
    _count: ClaimFileCountAggregateOutputType | null
    _avg: ClaimFileAvgAggregateOutputType | null
    _sum: ClaimFileSumAggregateOutputType | null
    _min: ClaimFileMinAggregateOutputType | null
    _max: ClaimFileMaxAggregateOutputType | null
  }

  export type ClaimFileAvgAggregateOutputType = {
    id: number | null
    claimId: number | null
  }

  export type ClaimFileSumAggregateOutputType = {
    id: number | null
    claimId: number | null
  }

  export type ClaimFileMinAggregateOutputType = {
    id: number | null
    claimId: number | null
    filename: string | null
    mimeType: string | null
    filePath: string | null
  }

  export type ClaimFileMaxAggregateOutputType = {
    id: number | null
    claimId: number | null
    filename: string | null
    mimeType: string | null
    filePath: string | null
  }

  export type ClaimFileCountAggregateOutputType = {
    id: number
    claimId: number
    filename: number
    mimeType: number
    filePath: number
    _all: number
  }


  export type ClaimFileAvgAggregateInputType = {
    id?: true
    claimId?: true
  }

  export type ClaimFileSumAggregateInputType = {
    id?: true
    claimId?: true
  }

  export type ClaimFileMinAggregateInputType = {
    id?: true
    claimId?: true
    filename?: true
    mimeType?: true
    filePath?: true
  }

  export type ClaimFileMaxAggregateInputType = {
    id?: true
    claimId?: true
    filename?: true
    mimeType?: true
    filePath?: true
  }

  export type ClaimFileCountAggregateInputType = {
    id?: true
    claimId?: true
    filename?: true
    mimeType?: true
    filePath?: true
    _all?: true
  }

  export type ClaimFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ClaimFile to aggregate.
     */
    where?: ClaimFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ClaimFiles to fetch.
     */
    orderBy?: ClaimFileOrderByWithRelationInput | ClaimFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ClaimFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ClaimFiles 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` ClaimFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ClaimFiles
    **/
    _count?: true | ClaimFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ClaimFileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ClaimFileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ClaimFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ClaimFileMaxAggregateInputType
  }

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




  export type ClaimFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ClaimFileWhereInput
    orderBy?: ClaimFileOrderByWithAggregationInput | ClaimFileOrderByWithAggregationInput[]
    by: ClaimFileScalarFieldEnum[] | ClaimFileScalarFieldEnum
    having?: ClaimFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ClaimFileCountAggregateInputType | true
    _avg?: ClaimFileAvgAggregateInputType
    _sum?: ClaimFileSumAggregateInputType
    _min?: ClaimFileMinAggregateInputType
    _max?: ClaimFileMaxAggregateInputType
  }

  export type ClaimFileGroupByOutputType = {
    id: number
    claimId: number
    filename: string
    mimeType: string
    filePath: string | null
    _count: ClaimFileCountAggregateOutputType | null
    _avg: ClaimFileAvgAggregateOutputType | null
    _sum: ClaimFileSumAggregateOutputType | null
    _min: ClaimFileMinAggregateOutputType | null
    _max: ClaimFileMaxAggregateOutputType | null
  }

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


  export type ClaimFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["claimFile"]>

  export type ClaimFileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["claimFile"]>

  export type ClaimFileSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["claimFile"]>

  export type ClaimFileSelectScalar = {
    id?: boolean
    claimId?: boolean
    filename?: boolean
    mimeType?: boolean
    filePath?: boolean
  }

  export type ClaimFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "claimId" | "filename" | "mimeType" | "filePath", ExtArgs["result"]["claimFile"]>
  export type ClaimFileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }
  export type ClaimFileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }
  export type ClaimFileIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }

  export type $ClaimFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ClaimFile"
    objects: {
      claim: Prisma.$ClaimPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      claimId: number
      filename: string
      mimeType: string
      filePath: string | null
    }, ExtArgs["result"]["claimFile"]>
    composites: {}
  }

  type ClaimFileGetPayload<S extends boolean | null | undefined | ClaimFileDefaultArgs> = $Result.GetResult<Prisma.$ClaimFilePayload, S>

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

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

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

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

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

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

    /**
     * Create a ClaimFile.
     * @param {ClaimFileCreateArgs} args - Arguments to create a ClaimFile.
     * @example
     * // Create one ClaimFile
     * const ClaimFile = await prisma.claimFile.create({
     *   data: {
     *     // ... data to create a ClaimFile
     *   }
     * })
     * 
     */
    create<T extends ClaimFileCreateArgs>(args: SelectSubset<T, ClaimFileCreateArgs<ExtArgs>>): Prisma__ClaimFileClient<$Result.GetResult<Prisma.$ClaimFilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ClaimFiles and returns the data saved in the database.
     * @param {ClaimFileCreateManyAndReturnArgs} args - Arguments to create many ClaimFiles.
     * @example
     * // Create many ClaimFiles
     * const claimFile = await prisma.claimFile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ClaimFiles and only return the `id`
     * const claimFileWithIdOnly = await prisma.claimFile.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 ClaimFileCreateManyAndReturnArgs>(args?: SelectSubset<T, ClaimFileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimFilePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ClaimFile.
     * @param {ClaimFileDeleteArgs} args - Arguments to delete one ClaimFile.
     * @example
     * // Delete one ClaimFile
     * const ClaimFile = await prisma.claimFile.delete({
     *   where: {
     *     // ... filter to delete one ClaimFile
     *   }
     * })
     * 
     */
    delete<T extends ClaimFileDeleteArgs>(args: SelectSubset<T, ClaimFileDeleteArgs<ExtArgs>>): Prisma__ClaimFileClient<$Result.GetResult<Prisma.$ClaimFilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more ClaimFiles and returns the data updated in the database.
     * @param {ClaimFileUpdateManyAndReturnArgs} args - Arguments to update many ClaimFiles.
     * @example
     * // Update many ClaimFiles
     * const claimFile = await prisma.claimFile.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ClaimFiles and only return the `id`
     * const claimFileWithIdOnly = await prisma.claimFile.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ClaimFileUpdateManyAndReturnArgs>(args: SelectSubset<T, ClaimFileUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimFilePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ClaimFile.
   * 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__ClaimFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    claim<T extends ClaimDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ClaimDefaultArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ClaimFile model
   */
  interface ClaimFileFieldRefs {
    readonly id: FieldRef<"ClaimFile", 'Int'>
    readonly claimId: FieldRef<"ClaimFile", 'Int'>
    readonly filename: FieldRef<"ClaimFile", 'String'>
    readonly mimeType: FieldRef<"ClaimFile", 'String'>
    readonly filePath: FieldRef<"ClaimFile", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ClaimFile findUnique
   */
  export type ClaimFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * Filter, which ClaimFile to fetch.
     */
    where: ClaimFileWhereUniqueInput
  }

  /**
   * ClaimFile findUniqueOrThrow
   */
  export type ClaimFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * Filter, which ClaimFile to fetch.
     */
    where: ClaimFileWhereUniqueInput
  }

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

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

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

  /**
   * ClaimFile create
   */
  export type ClaimFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * The data needed to create a ClaimFile.
     */
    data: XOR<ClaimFileCreateInput, ClaimFileUncheckedCreateInput>
  }

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

  /**
   * ClaimFile createManyAndReturn
   */
  export type ClaimFileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * The data used to create many ClaimFiles.
     */
    data: ClaimFileCreateManyInput | ClaimFileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ClaimFile update
   */
  export type ClaimFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * The data needed to update a ClaimFile.
     */
    data: XOR<ClaimFileUpdateInput, ClaimFileUncheckedUpdateInput>
    /**
     * Choose, which ClaimFile to update.
     */
    where: ClaimFileWhereUniqueInput
  }

  /**
   * ClaimFile updateMany
   */
  export type ClaimFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ClaimFiles.
     */
    data: XOR<ClaimFileUpdateManyMutationInput, ClaimFileUncheckedUpdateManyInput>
    /**
     * Filter which ClaimFiles to update
     */
    where?: ClaimFileWhereInput
    /**
     * Limit how many ClaimFiles to update.
     */
    limit?: number
  }

  /**
   * ClaimFile updateManyAndReturn
   */
  export type ClaimFileUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * The data used to update ClaimFiles.
     */
    data: XOR<ClaimFileUpdateManyMutationInput, ClaimFileUncheckedUpdateManyInput>
    /**
     * Filter which ClaimFiles to update
     */
    where?: ClaimFileWhereInput
    /**
     * Limit how many ClaimFiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ClaimFile upsert
   */
  export type ClaimFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * The filter to search for the ClaimFile to update in case it exists.
     */
    where: ClaimFileWhereUniqueInput
    /**
     * In case the ClaimFile found by the `where` argument doesn't exist, create a new ClaimFile with this data.
     */
    create: XOR<ClaimFileCreateInput, ClaimFileUncheckedCreateInput>
    /**
     * In case the ClaimFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ClaimFileUpdateInput, ClaimFileUncheckedUpdateInput>
  }

  /**
   * ClaimFile delete
   */
  export type ClaimFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ClaimFile
     */
    select?: ClaimFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ClaimFile
     */
    omit?: ClaimFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimFileInclude<ExtArgs> | null
    /**
     * Filter which ClaimFile to delete.
     */
    where: ClaimFileWhereUniqueInput
  }

  /**
   * ClaimFile deleteMany
   */
  export type ClaimFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ClaimFiles to delete
     */
    where?: ClaimFileWhereInput
    /**
     * Limit how many ClaimFiles to delete.
     */
    limit?: number
  }

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


  /**
   * Model InsuranceCredential
   */

  export type AggregateInsuranceCredential = {
    _count: InsuranceCredentialCountAggregateOutputType | null
    _avg: InsuranceCredentialAvgAggregateOutputType | null
    _sum: InsuranceCredentialSumAggregateOutputType | null
    _min: InsuranceCredentialMinAggregateOutputType | null
    _max: InsuranceCredentialMaxAggregateOutputType | null
  }

  export type InsuranceCredentialAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type InsuranceCredentialSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type InsuranceCredentialMinAggregateOutputType = {
    id: number | null
    userId: number | null
    siteKey: string | null
    username: string | null
    password: string | null
  }

  export type InsuranceCredentialMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    siteKey: string | null
    username: string | null
    password: string | null
  }

  export type InsuranceCredentialCountAggregateOutputType = {
    id: number
    userId: number
    siteKey: number
    username: number
    password: number
    _all: number
  }


  export type InsuranceCredentialAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type InsuranceCredentialSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type InsuranceCredentialMinAggregateInputType = {
    id?: true
    userId?: true
    siteKey?: true
    username?: true
    password?: true
  }

  export type InsuranceCredentialMaxAggregateInputType = {
    id?: true
    userId?: true
    siteKey?: true
    username?: true
    password?: true
  }

  export type InsuranceCredentialCountAggregateInputType = {
    id?: true
    userId?: true
    siteKey?: true
    username?: true
    password?: true
    _all?: true
  }

  export type InsuranceCredentialAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InsuranceCredential to aggregate.
     */
    where?: InsuranceCredentialWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InsuranceCredentials to fetch.
     */
    orderBy?: InsuranceCredentialOrderByWithRelationInput | InsuranceCredentialOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: InsuranceCredentialWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InsuranceCredentials 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` InsuranceCredentials.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned InsuranceCredentials
    **/
    _count?: true | InsuranceCredentialCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: InsuranceCredentialAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: InsuranceCredentialSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: InsuranceCredentialMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: InsuranceCredentialMaxAggregateInputType
  }

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




  export type InsuranceCredentialGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: InsuranceCredentialWhereInput
    orderBy?: InsuranceCredentialOrderByWithAggregationInput | InsuranceCredentialOrderByWithAggregationInput[]
    by: InsuranceCredentialScalarFieldEnum[] | InsuranceCredentialScalarFieldEnum
    having?: InsuranceCredentialScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: InsuranceCredentialCountAggregateInputType | true
    _avg?: InsuranceCredentialAvgAggregateInputType
    _sum?: InsuranceCredentialSumAggregateInputType
    _min?: InsuranceCredentialMinAggregateInputType
    _max?: InsuranceCredentialMaxAggregateInputType
  }

  export type InsuranceCredentialGroupByOutputType = {
    id: number
    userId: number
    siteKey: string
    username: string
    password: string
    _count: InsuranceCredentialCountAggregateOutputType | null
    _avg: InsuranceCredentialAvgAggregateOutputType | null
    _sum: InsuranceCredentialSumAggregateOutputType | null
    _min: InsuranceCredentialMinAggregateOutputType | null
    _max: InsuranceCredentialMaxAggregateOutputType | null
  }

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


  export type InsuranceCredentialSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    siteKey?: boolean
    username?: boolean
    password?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["insuranceCredential"]>

  export type InsuranceCredentialSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    siteKey?: boolean
    username?: boolean
    password?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["insuranceCredential"]>

  export type InsuranceCredentialSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    siteKey?: boolean
    username?: boolean
    password?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["insuranceCredential"]>

  export type InsuranceCredentialSelectScalar = {
    id?: boolean
    userId?: boolean
    siteKey?: boolean
    username?: boolean
    password?: boolean
  }

  export type InsuranceCredentialOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "siteKey" | "username" | "password", ExtArgs["result"]["insuranceCredential"]>
  export type InsuranceCredentialInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type InsuranceCredentialIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type InsuranceCredentialIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $InsuranceCredentialPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "InsuranceCredential"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      siteKey: string
      username: string
      password: string
    }, ExtArgs["result"]["insuranceCredential"]>
    composites: {}
  }

  type InsuranceCredentialGetPayload<S extends boolean | null | undefined | InsuranceCredentialDefaultArgs> = $Result.GetResult<Prisma.$InsuranceCredentialPayload, S>

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

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

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

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

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

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

    /**
     * Create a InsuranceCredential.
     * @param {InsuranceCredentialCreateArgs} args - Arguments to create a InsuranceCredential.
     * @example
     * // Create one InsuranceCredential
     * const InsuranceCredential = await prisma.insuranceCredential.create({
     *   data: {
     *     // ... data to create a InsuranceCredential
     *   }
     * })
     * 
     */
    create<T extends InsuranceCredentialCreateArgs>(args: SelectSubset<T, InsuranceCredentialCreateArgs<ExtArgs>>): Prisma__InsuranceCredentialClient<$Result.GetResult<Prisma.$InsuranceCredentialPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many InsuranceCredentials and returns the data saved in the database.
     * @param {InsuranceCredentialCreateManyAndReturnArgs} args - Arguments to create many InsuranceCredentials.
     * @example
     * // Create many InsuranceCredentials
     * const insuranceCredential = await prisma.insuranceCredential.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many InsuranceCredentials and only return the `id`
     * const insuranceCredentialWithIdOnly = await prisma.insuranceCredential.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 InsuranceCredentialCreateManyAndReturnArgs>(args?: SelectSubset<T, InsuranceCredentialCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceCredentialPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a InsuranceCredential.
     * @param {InsuranceCredentialDeleteArgs} args - Arguments to delete one InsuranceCredential.
     * @example
     * // Delete one InsuranceCredential
     * const InsuranceCredential = await prisma.insuranceCredential.delete({
     *   where: {
     *     // ... filter to delete one InsuranceCredential
     *   }
     * })
     * 
     */
    delete<T extends InsuranceCredentialDeleteArgs>(args: SelectSubset<T, InsuranceCredentialDeleteArgs<ExtArgs>>): Prisma__InsuranceCredentialClient<$Result.GetResult<Prisma.$InsuranceCredentialPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more InsuranceCredentials and returns the data updated in the database.
     * @param {InsuranceCredentialUpdateManyAndReturnArgs} args - Arguments to update many InsuranceCredentials.
     * @example
     * // Update many InsuranceCredentials
     * const insuranceCredential = await prisma.insuranceCredential.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more InsuranceCredentials and only return the `id`
     * const insuranceCredentialWithIdOnly = await prisma.insuranceCredential.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends InsuranceCredentialUpdateManyAndReturnArgs>(args: SelectSubset<T, InsuranceCredentialUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceCredentialPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for InsuranceCredential.
   * 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__InsuranceCredentialClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the InsuranceCredential model
   */
  interface InsuranceCredentialFieldRefs {
    readonly id: FieldRef<"InsuranceCredential", 'Int'>
    readonly userId: FieldRef<"InsuranceCredential", 'Int'>
    readonly siteKey: FieldRef<"InsuranceCredential", 'String'>
    readonly username: FieldRef<"InsuranceCredential", 'String'>
    readonly password: FieldRef<"InsuranceCredential", 'String'>
  }
    

  // Custom InputTypes
  /**
   * InsuranceCredential findUnique
   */
  export type InsuranceCredentialFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * Filter, which InsuranceCredential to fetch.
     */
    where: InsuranceCredentialWhereUniqueInput
  }

  /**
   * InsuranceCredential findUniqueOrThrow
   */
  export type InsuranceCredentialFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * Filter, which InsuranceCredential to fetch.
     */
    where: InsuranceCredentialWhereUniqueInput
  }

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

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

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

  /**
   * InsuranceCredential create
   */
  export type InsuranceCredentialCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * The data needed to create a InsuranceCredential.
     */
    data: XOR<InsuranceCredentialCreateInput, InsuranceCredentialUncheckedCreateInput>
  }

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

  /**
   * InsuranceCredential createManyAndReturn
   */
  export type InsuranceCredentialCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * The data used to create many InsuranceCredentials.
     */
    data: InsuranceCredentialCreateManyInput | InsuranceCredentialCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * InsuranceCredential update
   */
  export type InsuranceCredentialUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * The data needed to update a InsuranceCredential.
     */
    data: XOR<InsuranceCredentialUpdateInput, InsuranceCredentialUncheckedUpdateInput>
    /**
     * Choose, which InsuranceCredential to update.
     */
    where: InsuranceCredentialWhereUniqueInput
  }

  /**
   * InsuranceCredential updateMany
   */
  export type InsuranceCredentialUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update InsuranceCredentials.
     */
    data: XOR<InsuranceCredentialUpdateManyMutationInput, InsuranceCredentialUncheckedUpdateManyInput>
    /**
     * Filter which InsuranceCredentials to update
     */
    where?: InsuranceCredentialWhereInput
    /**
     * Limit how many InsuranceCredentials to update.
     */
    limit?: number
  }

  /**
   * InsuranceCredential updateManyAndReturn
   */
  export type InsuranceCredentialUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * The data used to update InsuranceCredentials.
     */
    data: XOR<InsuranceCredentialUpdateManyMutationInput, InsuranceCredentialUncheckedUpdateManyInput>
    /**
     * Filter which InsuranceCredentials to update
     */
    where?: InsuranceCredentialWhereInput
    /**
     * Limit how many InsuranceCredentials to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * InsuranceCredential upsert
   */
  export type InsuranceCredentialUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * The filter to search for the InsuranceCredential to update in case it exists.
     */
    where: InsuranceCredentialWhereUniqueInput
    /**
     * In case the InsuranceCredential found by the `where` argument doesn't exist, create a new InsuranceCredential with this data.
     */
    create: XOR<InsuranceCredentialCreateInput, InsuranceCredentialUncheckedCreateInput>
    /**
     * In case the InsuranceCredential was found with the provided `where` argument, update it with this data.
     */
    update: XOR<InsuranceCredentialUpdateInput, InsuranceCredentialUncheckedUpdateInput>
  }

  /**
   * InsuranceCredential delete
   */
  export type InsuranceCredentialDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceCredential
     */
    select?: InsuranceCredentialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceCredential
     */
    omit?: InsuranceCredentialOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceCredentialInclude<ExtArgs> | null
    /**
     * Filter which InsuranceCredential to delete.
     */
    where: InsuranceCredentialWhereUniqueInput
  }

  /**
   * InsuranceCredential deleteMany
   */
  export type InsuranceCredentialDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InsuranceCredentials to delete
     */
    where?: InsuranceCredentialWhereInput
    /**
     * Limit how many InsuranceCredentials to delete.
     */
    limit?: number
  }

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


  /**
   * Model ShoppingVendor
   */

  export type AggregateShoppingVendor = {
    _count: ShoppingVendorCountAggregateOutputType | null
    _avg: ShoppingVendorAvgAggregateOutputType | null
    _sum: ShoppingVendorSumAggregateOutputType | null
    _min: ShoppingVendorMinAggregateOutputType | null
    _max: ShoppingVendorMaxAggregateOutputType | null
  }

  export type ShoppingVendorAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ShoppingVendorSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ShoppingVendorMinAggregateOutputType = {
    id: number | null
    userId: number | null
    vendorName: string | null
    websiteUrl: string | null
    loginUsername: string | null
    loginPassword: string | null
  }

  export type ShoppingVendorMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    vendorName: string | null
    websiteUrl: string | null
    loginUsername: string | null
    loginPassword: string | null
  }

  export type ShoppingVendorCountAggregateOutputType = {
    id: number
    userId: number
    vendorName: number
    websiteUrl: number
    loginUsername: number
    loginPassword: number
    _all: number
  }


  export type ShoppingVendorAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ShoppingVendorSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ShoppingVendorMinAggregateInputType = {
    id?: true
    userId?: true
    vendorName?: true
    websiteUrl?: true
    loginUsername?: true
    loginPassword?: true
  }

  export type ShoppingVendorMaxAggregateInputType = {
    id?: true
    userId?: true
    vendorName?: true
    websiteUrl?: true
    loginUsername?: true
    loginPassword?: true
  }

  export type ShoppingVendorCountAggregateInputType = {
    id?: true
    userId?: true
    vendorName?: true
    websiteUrl?: true
    loginUsername?: true
    loginPassword?: true
    _all?: true
  }

  export type ShoppingVendorAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ShoppingVendor to aggregate.
     */
    where?: ShoppingVendorWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ShoppingVendors to fetch.
     */
    orderBy?: ShoppingVendorOrderByWithRelationInput | ShoppingVendorOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ShoppingVendorWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ShoppingVendors 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` ShoppingVendors.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ShoppingVendors
    **/
    _count?: true | ShoppingVendorCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ShoppingVendorAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ShoppingVendorSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ShoppingVendorMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ShoppingVendorMaxAggregateInputType
  }

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




  export type ShoppingVendorGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ShoppingVendorWhereInput
    orderBy?: ShoppingVendorOrderByWithAggregationInput | ShoppingVendorOrderByWithAggregationInput[]
    by: ShoppingVendorScalarFieldEnum[] | ShoppingVendorScalarFieldEnum
    having?: ShoppingVendorScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ShoppingVendorCountAggregateInputType | true
    _avg?: ShoppingVendorAvgAggregateInputType
    _sum?: ShoppingVendorSumAggregateInputType
    _min?: ShoppingVendorMinAggregateInputType
    _max?: ShoppingVendorMaxAggregateInputType
  }

  export type ShoppingVendorGroupByOutputType = {
    id: number
    userId: number
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
    _count: ShoppingVendorCountAggregateOutputType | null
    _avg: ShoppingVendorAvgAggregateOutputType | null
    _sum: ShoppingVendorSumAggregateOutputType | null
    _min: ShoppingVendorMinAggregateOutputType | null
    _max: ShoppingVendorMaxAggregateOutputType | null
  }

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


  export type ShoppingVendorSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    vendorName?: boolean
    websiteUrl?: boolean
    loginUsername?: boolean
    loginPassword?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["shoppingVendor"]>

  export type ShoppingVendorSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    vendorName?: boolean
    websiteUrl?: boolean
    loginUsername?: boolean
    loginPassword?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["shoppingVendor"]>

  export type ShoppingVendorSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    vendorName?: boolean
    websiteUrl?: boolean
    loginUsername?: boolean
    loginPassword?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["shoppingVendor"]>

  export type ShoppingVendorSelectScalar = {
    id?: boolean
    userId?: boolean
    vendorName?: boolean
    websiteUrl?: boolean
    loginUsername?: boolean
    loginPassword?: boolean
  }

  export type ShoppingVendorOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "vendorName" | "websiteUrl" | "loginUsername" | "loginPassword", ExtArgs["result"]["shoppingVendor"]>
  export type ShoppingVendorInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ShoppingVendorIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ShoppingVendorIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ShoppingVendorPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ShoppingVendor"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      vendorName: string
      websiteUrl: string
      loginUsername: string
      loginPassword: string
    }, ExtArgs["result"]["shoppingVendor"]>
    composites: {}
  }

  type ShoppingVendorGetPayload<S extends boolean | null | undefined | ShoppingVendorDefaultArgs> = $Result.GetResult<Prisma.$ShoppingVendorPayload, S>

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

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

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

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

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

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

    /**
     * Create a ShoppingVendor.
     * @param {ShoppingVendorCreateArgs} args - Arguments to create a ShoppingVendor.
     * @example
     * // Create one ShoppingVendor
     * const ShoppingVendor = await prisma.shoppingVendor.create({
     *   data: {
     *     // ... data to create a ShoppingVendor
     *   }
     * })
     * 
     */
    create<T extends ShoppingVendorCreateArgs>(args: SelectSubset<T, ShoppingVendorCreateArgs<ExtArgs>>): Prisma__ShoppingVendorClient<$Result.GetResult<Prisma.$ShoppingVendorPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ShoppingVendors and returns the data saved in the database.
     * @param {ShoppingVendorCreateManyAndReturnArgs} args - Arguments to create many ShoppingVendors.
     * @example
     * // Create many ShoppingVendors
     * const shoppingVendor = await prisma.shoppingVendor.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ShoppingVendors and only return the `id`
     * const shoppingVendorWithIdOnly = await prisma.shoppingVendor.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 ShoppingVendorCreateManyAndReturnArgs>(args?: SelectSubset<T, ShoppingVendorCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ShoppingVendorPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ShoppingVendor.
     * @param {ShoppingVendorDeleteArgs} args - Arguments to delete one ShoppingVendor.
     * @example
     * // Delete one ShoppingVendor
     * const ShoppingVendor = await prisma.shoppingVendor.delete({
     *   where: {
     *     // ... filter to delete one ShoppingVendor
     *   }
     * })
     * 
     */
    delete<T extends ShoppingVendorDeleteArgs>(args: SelectSubset<T, ShoppingVendorDeleteArgs<ExtArgs>>): Prisma__ShoppingVendorClient<$Result.GetResult<Prisma.$ShoppingVendorPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more ShoppingVendors and returns the data updated in the database.
     * @param {ShoppingVendorUpdateManyAndReturnArgs} args - Arguments to update many ShoppingVendors.
     * @example
     * // Update many ShoppingVendors
     * const shoppingVendor = await prisma.shoppingVendor.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ShoppingVendors and only return the `id`
     * const shoppingVendorWithIdOnly = await prisma.shoppingVendor.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ShoppingVendorUpdateManyAndReturnArgs>(args: SelectSubset<T, ShoppingVendorUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ShoppingVendorPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ShoppingVendor.
   * 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__ShoppingVendorClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ShoppingVendor model
   */
  interface ShoppingVendorFieldRefs {
    readonly id: FieldRef<"ShoppingVendor", 'Int'>
    readonly userId: FieldRef<"ShoppingVendor", 'Int'>
    readonly vendorName: FieldRef<"ShoppingVendor", 'String'>
    readonly websiteUrl: FieldRef<"ShoppingVendor", 'String'>
    readonly loginUsername: FieldRef<"ShoppingVendor", 'String'>
    readonly loginPassword: FieldRef<"ShoppingVendor", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ShoppingVendor findUnique
   */
  export type ShoppingVendorFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * Filter, which ShoppingVendor to fetch.
     */
    where: ShoppingVendorWhereUniqueInput
  }

  /**
   * ShoppingVendor findUniqueOrThrow
   */
  export type ShoppingVendorFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * Filter, which ShoppingVendor to fetch.
     */
    where: ShoppingVendorWhereUniqueInput
  }

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

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

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

  /**
   * ShoppingVendor create
   */
  export type ShoppingVendorCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * The data needed to create a ShoppingVendor.
     */
    data: XOR<ShoppingVendorCreateInput, ShoppingVendorUncheckedCreateInput>
  }

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

  /**
   * ShoppingVendor createManyAndReturn
   */
  export type ShoppingVendorCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * The data used to create many ShoppingVendors.
     */
    data: ShoppingVendorCreateManyInput | ShoppingVendorCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ShoppingVendor update
   */
  export type ShoppingVendorUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * The data needed to update a ShoppingVendor.
     */
    data: XOR<ShoppingVendorUpdateInput, ShoppingVendorUncheckedUpdateInput>
    /**
     * Choose, which ShoppingVendor to update.
     */
    where: ShoppingVendorWhereUniqueInput
  }

  /**
   * ShoppingVendor updateMany
   */
  export type ShoppingVendorUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ShoppingVendors.
     */
    data: XOR<ShoppingVendorUpdateManyMutationInput, ShoppingVendorUncheckedUpdateManyInput>
    /**
     * Filter which ShoppingVendors to update
     */
    where?: ShoppingVendorWhereInput
    /**
     * Limit how many ShoppingVendors to update.
     */
    limit?: number
  }

  /**
   * ShoppingVendor updateManyAndReturn
   */
  export type ShoppingVendorUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * The data used to update ShoppingVendors.
     */
    data: XOR<ShoppingVendorUpdateManyMutationInput, ShoppingVendorUncheckedUpdateManyInput>
    /**
     * Filter which ShoppingVendors to update
     */
    where?: ShoppingVendorWhereInput
    /**
     * Limit how many ShoppingVendors to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ShoppingVendor upsert
   */
  export type ShoppingVendorUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * The filter to search for the ShoppingVendor to update in case it exists.
     */
    where: ShoppingVendorWhereUniqueInput
    /**
     * In case the ShoppingVendor found by the `where` argument doesn't exist, create a new ShoppingVendor with this data.
     */
    create: XOR<ShoppingVendorCreateInput, ShoppingVendorUncheckedCreateInput>
    /**
     * In case the ShoppingVendor was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ShoppingVendorUpdateInput, ShoppingVendorUncheckedUpdateInput>
  }

  /**
   * ShoppingVendor delete
   */
  export type ShoppingVendorDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShoppingVendor
     */
    select?: ShoppingVendorSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ShoppingVendor
     */
    omit?: ShoppingVendorOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ShoppingVendorInclude<ExtArgs> | null
    /**
     * Filter which ShoppingVendor to delete.
     */
    where: ShoppingVendorWhereUniqueInput
  }

  /**
   * ShoppingVendor deleteMany
   */
  export type ShoppingVendorDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ShoppingVendors to delete
     */
    where?: ShoppingVendorWhereInput
    /**
     * Limit how many ShoppingVendors to delete.
     */
    limit?: number
  }

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


  /**
   * Model PdfGroup
   */

  export type AggregatePdfGroup = {
    _count: PdfGroupCountAggregateOutputType | null
    _avg: PdfGroupAvgAggregateOutputType | null
    _sum: PdfGroupSumAggregateOutputType | null
    _min: PdfGroupMinAggregateOutputType | null
    _max: PdfGroupMaxAggregateOutputType | null
  }

  export type PdfGroupAvgAggregateOutputType = {
    id: number | null
    patientId: number | null
  }

  export type PdfGroupSumAggregateOutputType = {
    id: number | null
    patientId: number | null
  }

  export type PdfGroupMinAggregateOutputType = {
    id: number | null
    title: string | null
    titleKey: $Enums.PdfTitleKey | null
    createdAt: Date | null
    patientId: number | null
  }

  export type PdfGroupMaxAggregateOutputType = {
    id: number | null
    title: string | null
    titleKey: $Enums.PdfTitleKey | null
    createdAt: Date | null
    patientId: number | null
  }

  export type PdfGroupCountAggregateOutputType = {
    id: number
    title: number
    titleKey: number
    createdAt: number
    patientId: number
    _all: number
  }


  export type PdfGroupAvgAggregateInputType = {
    id?: true
    patientId?: true
  }

  export type PdfGroupSumAggregateInputType = {
    id?: true
    patientId?: true
  }

  export type PdfGroupMinAggregateInputType = {
    id?: true
    title?: true
    titleKey?: true
    createdAt?: true
    patientId?: true
  }

  export type PdfGroupMaxAggregateInputType = {
    id?: true
    title?: true
    titleKey?: true
    createdAt?: true
    patientId?: true
  }

  export type PdfGroupCountAggregateInputType = {
    id?: true
    title?: true
    titleKey?: true
    createdAt?: true
    patientId?: true
    _all?: true
  }

  export type PdfGroupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PdfGroup to aggregate.
     */
    where?: PdfGroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PdfGroups to fetch.
     */
    orderBy?: PdfGroupOrderByWithRelationInput | PdfGroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PdfGroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PdfGroups 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` PdfGroups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PdfGroups
    **/
    _count?: true | PdfGroupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PdfGroupAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PdfGroupSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PdfGroupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PdfGroupMaxAggregateInputType
  }

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




  export type PdfGroupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PdfGroupWhereInput
    orderBy?: PdfGroupOrderByWithAggregationInput | PdfGroupOrderByWithAggregationInput[]
    by: PdfGroupScalarFieldEnum[] | PdfGroupScalarFieldEnum
    having?: PdfGroupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PdfGroupCountAggregateInputType | true
    _avg?: PdfGroupAvgAggregateInputType
    _sum?: PdfGroupSumAggregateInputType
    _min?: PdfGroupMinAggregateInputType
    _max?: PdfGroupMaxAggregateInputType
  }

  export type PdfGroupGroupByOutputType = {
    id: number
    title: string
    titleKey: $Enums.PdfTitleKey
    createdAt: Date
    patientId: number
    _count: PdfGroupCountAggregateOutputType | null
    _avg: PdfGroupAvgAggregateOutputType | null
    _sum: PdfGroupSumAggregateOutputType | null
    _min: PdfGroupMinAggregateOutputType | null
    _max: PdfGroupMaxAggregateOutputType | null
  }

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


  export type PdfGroupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    titleKey?: boolean
    createdAt?: boolean
    patientId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    pdfs?: boolean | PdfGroup$pdfsArgs<ExtArgs>
    _count?: boolean | PdfGroupCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfGroup"]>

  export type PdfGroupSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    titleKey?: boolean
    createdAt?: boolean
    patientId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfGroup"]>

  export type PdfGroupSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    titleKey?: boolean
    createdAt?: boolean
    patientId?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfGroup"]>

  export type PdfGroupSelectScalar = {
    id?: boolean
    title?: boolean
    titleKey?: boolean
    createdAt?: boolean
    patientId?: boolean
  }

  export type PdfGroupOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "title" | "titleKey" | "createdAt" | "patientId", ExtArgs["result"]["pdfGroup"]>
  export type PdfGroupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    pdfs?: boolean | PdfGroup$pdfsArgs<ExtArgs>
    _count?: boolean | PdfGroupCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PdfGroupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }
  export type PdfGroupIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }

  export type $PdfGroupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PdfGroup"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      pdfs: Prisma.$PdfFilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
      titleKey: $Enums.PdfTitleKey
      createdAt: Date
      patientId: number
    }, ExtArgs["result"]["pdfGroup"]>
    composites: {}
  }

  type PdfGroupGetPayload<S extends boolean | null | undefined | PdfGroupDefaultArgs> = $Result.GetResult<Prisma.$PdfGroupPayload, S>

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

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

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

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

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

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

    /**
     * Create a PdfGroup.
     * @param {PdfGroupCreateArgs} args - Arguments to create a PdfGroup.
     * @example
     * // Create one PdfGroup
     * const PdfGroup = await prisma.pdfGroup.create({
     *   data: {
     *     // ... data to create a PdfGroup
     *   }
     * })
     * 
     */
    create<T extends PdfGroupCreateArgs>(args: SelectSubset<T, PdfGroupCreateArgs<ExtArgs>>): Prisma__PdfGroupClient<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many PdfGroups and returns the data saved in the database.
     * @param {PdfGroupCreateManyAndReturnArgs} args - Arguments to create many PdfGroups.
     * @example
     * // Create many PdfGroups
     * const pdfGroup = await prisma.pdfGroup.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many PdfGroups and only return the `id`
     * const pdfGroupWithIdOnly = await prisma.pdfGroup.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 PdfGroupCreateManyAndReturnArgs>(args?: SelectSubset<T, PdfGroupCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a PdfGroup.
     * @param {PdfGroupDeleteArgs} args - Arguments to delete one PdfGroup.
     * @example
     * // Delete one PdfGroup
     * const PdfGroup = await prisma.pdfGroup.delete({
     *   where: {
     *     // ... filter to delete one PdfGroup
     *   }
     * })
     * 
     */
    delete<T extends PdfGroupDeleteArgs>(args: SelectSubset<T, PdfGroupDeleteArgs<ExtArgs>>): Prisma__PdfGroupClient<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more PdfGroups and returns the data updated in the database.
     * @param {PdfGroupUpdateManyAndReturnArgs} args - Arguments to update many PdfGroups.
     * @example
     * // Update many PdfGroups
     * const pdfGroup = await prisma.pdfGroup.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more PdfGroups and only return the `id`
     * const pdfGroupWithIdOnly = await prisma.pdfGroup.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PdfGroupUpdateManyAndReturnArgs>(args: SelectSubset<T, PdfGroupUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PdfGroup.
   * 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__PdfGroupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    pdfs<T extends PdfGroup$pdfsArgs<ExtArgs> = {}>(args?: Subset<T, PdfGroup$pdfsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfFilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PdfGroup model
   */
  interface PdfGroupFieldRefs {
    readonly id: FieldRef<"PdfGroup", 'Int'>
    readonly title: FieldRef<"PdfGroup", 'String'>
    readonly titleKey: FieldRef<"PdfGroup", 'PdfTitleKey'>
    readonly createdAt: FieldRef<"PdfGroup", 'DateTime'>
    readonly patientId: FieldRef<"PdfGroup", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * PdfGroup findUnique
   */
  export type PdfGroupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * Filter, which PdfGroup to fetch.
     */
    where: PdfGroupWhereUniqueInput
  }

  /**
   * PdfGroup findUniqueOrThrow
   */
  export type PdfGroupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * Filter, which PdfGroup to fetch.
     */
    where: PdfGroupWhereUniqueInput
  }

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

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

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

  /**
   * PdfGroup create
   */
  export type PdfGroupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * The data needed to create a PdfGroup.
     */
    data: XOR<PdfGroupCreateInput, PdfGroupUncheckedCreateInput>
  }

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

  /**
   * PdfGroup createManyAndReturn
   */
  export type PdfGroupCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * The data used to create many PdfGroups.
     */
    data: PdfGroupCreateManyInput | PdfGroupCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PdfGroup update
   */
  export type PdfGroupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * The data needed to update a PdfGroup.
     */
    data: XOR<PdfGroupUpdateInput, PdfGroupUncheckedUpdateInput>
    /**
     * Choose, which PdfGroup to update.
     */
    where: PdfGroupWhereUniqueInput
  }

  /**
   * PdfGroup updateMany
   */
  export type PdfGroupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PdfGroups.
     */
    data: XOR<PdfGroupUpdateManyMutationInput, PdfGroupUncheckedUpdateManyInput>
    /**
     * Filter which PdfGroups to update
     */
    where?: PdfGroupWhereInput
    /**
     * Limit how many PdfGroups to update.
     */
    limit?: number
  }

  /**
   * PdfGroup updateManyAndReturn
   */
  export type PdfGroupUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * The data used to update PdfGroups.
     */
    data: XOR<PdfGroupUpdateManyMutationInput, PdfGroupUncheckedUpdateManyInput>
    /**
     * Filter which PdfGroups to update
     */
    where?: PdfGroupWhereInput
    /**
     * Limit how many PdfGroups to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * PdfGroup upsert
   */
  export type PdfGroupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * The filter to search for the PdfGroup to update in case it exists.
     */
    where: PdfGroupWhereUniqueInput
    /**
     * In case the PdfGroup found by the `where` argument doesn't exist, create a new PdfGroup with this data.
     */
    create: XOR<PdfGroupCreateInput, PdfGroupUncheckedCreateInput>
    /**
     * In case the PdfGroup was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PdfGroupUpdateInput, PdfGroupUncheckedUpdateInput>
  }

  /**
   * PdfGroup delete
   */
  export type PdfGroupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfGroup
     */
    select?: PdfGroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfGroup
     */
    omit?: PdfGroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfGroupInclude<ExtArgs> | null
    /**
     * Filter which PdfGroup to delete.
     */
    where: PdfGroupWhereUniqueInput
  }

  /**
   * PdfGroup deleteMany
   */
  export type PdfGroupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PdfGroups to delete
     */
    where?: PdfGroupWhereInput
    /**
     * Limit how many PdfGroups to delete.
     */
    limit?: number
  }

  /**
   * PdfGroup.pdfs
   */
  export type PdfGroup$pdfsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    where?: PdfFileWhereInput
    orderBy?: PdfFileOrderByWithRelationInput | PdfFileOrderByWithRelationInput[]
    cursor?: PdfFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PdfFileScalarFieldEnum | PdfFileScalarFieldEnum[]
  }

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


  /**
   * Model PdfFile
   */

  export type AggregatePdfFile = {
    _count: PdfFileCountAggregateOutputType | null
    _avg: PdfFileAvgAggregateOutputType | null
    _sum: PdfFileSumAggregateOutputType | null
    _min: PdfFileMinAggregateOutputType | null
    _max: PdfFileMaxAggregateOutputType | null
  }

  export type PdfFileAvgAggregateOutputType = {
    id: number | null
    groupId: number | null
  }

  export type PdfFileSumAggregateOutputType = {
    id: number | null
    groupId: number | null
  }

  export type PdfFileMinAggregateOutputType = {
    id: number | null
    filename: string | null
    pdfData: Bytes | null
    uploadedAt: Date | null
    groupId: number | null
  }

  export type PdfFileMaxAggregateOutputType = {
    id: number | null
    filename: string | null
    pdfData: Bytes | null
    uploadedAt: Date | null
    groupId: number | null
  }

  export type PdfFileCountAggregateOutputType = {
    id: number
    filename: number
    pdfData: number
    uploadedAt: number
    groupId: number
    _all: number
  }


  export type PdfFileAvgAggregateInputType = {
    id?: true
    groupId?: true
  }

  export type PdfFileSumAggregateInputType = {
    id?: true
    groupId?: true
  }

  export type PdfFileMinAggregateInputType = {
    id?: true
    filename?: true
    pdfData?: true
    uploadedAt?: true
    groupId?: true
  }

  export type PdfFileMaxAggregateInputType = {
    id?: true
    filename?: true
    pdfData?: true
    uploadedAt?: true
    groupId?: true
  }

  export type PdfFileCountAggregateInputType = {
    id?: true
    filename?: true
    pdfData?: true
    uploadedAt?: true
    groupId?: true
    _all?: true
  }

  export type PdfFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PdfFile to aggregate.
     */
    where?: PdfFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PdfFiles to fetch.
     */
    orderBy?: PdfFileOrderByWithRelationInput | PdfFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PdfFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PdfFiles 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` PdfFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PdfFiles
    **/
    _count?: true | PdfFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PdfFileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PdfFileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PdfFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PdfFileMaxAggregateInputType
  }

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




  export type PdfFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PdfFileWhereInput
    orderBy?: PdfFileOrderByWithAggregationInput | PdfFileOrderByWithAggregationInput[]
    by: PdfFileScalarFieldEnum[] | PdfFileScalarFieldEnum
    having?: PdfFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PdfFileCountAggregateInputType | true
    _avg?: PdfFileAvgAggregateInputType
    _sum?: PdfFileSumAggregateInputType
    _min?: PdfFileMinAggregateInputType
    _max?: PdfFileMaxAggregateInputType
  }

  export type PdfFileGroupByOutputType = {
    id: number
    filename: string
    pdfData: Bytes
    uploadedAt: Date
    groupId: number
    _count: PdfFileCountAggregateOutputType | null
    _avg: PdfFileAvgAggregateOutputType | null
    _sum: PdfFileSumAggregateOutputType | null
    _min: PdfFileMinAggregateOutputType | null
    _max: PdfFileMaxAggregateOutputType | null
  }

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


  export type PdfFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    filename?: boolean
    pdfData?: boolean
    uploadedAt?: boolean
    groupId?: boolean
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfFile"]>

  export type PdfFileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    filename?: boolean
    pdfData?: boolean
    uploadedAt?: boolean
    groupId?: boolean
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfFile"]>

  export type PdfFileSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    filename?: boolean
    pdfData?: boolean
    uploadedAt?: boolean
    groupId?: boolean
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pdfFile"]>

  export type PdfFileSelectScalar = {
    id?: boolean
    filename?: boolean
    pdfData?: boolean
    uploadedAt?: boolean
    groupId?: boolean
  }

  export type PdfFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "filename" | "pdfData" | "uploadedAt" | "groupId", ExtArgs["result"]["pdfFile"]>
  export type PdfFileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }
  export type PdfFileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }
  export type PdfFileIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | PdfGroupDefaultArgs<ExtArgs>
  }

  export type $PdfFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PdfFile"
    objects: {
      group: Prisma.$PdfGroupPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      filename: string
      pdfData: Prisma.Bytes
      uploadedAt: Date
      groupId: number
    }, ExtArgs["result"]["pdfFile"]>
    composites: {}
  }

  type PdfFileGetPayload<S extends boolean | null | undefined | PdfFileDefaultArgs> = $Result.GetResult<Prisma.$PdfFilePayload, S>

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

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

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

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

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

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

    /**
     * Create a PdfFile.
     * @param {PdfFileCreateArgs} args - Arguments to create a PdfFile.
     * @example
     * // Create one PdfFile
     * const PdfFile = await prisma.pdfFile.create({
     *   data: {
     *     // ... data to create a PdfFile
     *   }
     * })
     * 
     */
    create<T extends PdfFileCreateArgs>(args: SelectSubset<T, PdfFileCreateArgs<ExtArgs>>): Prisma__PdfFileClient<$Result.GetResult<Prisma.$PdfFilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many PdfFiles and returns the data saved in the database.
     * @param {PdfFileCreateManyAndReturnArgs} args - Arguments to create many PdfFiles.
     * @example
     * // Create many PdfFiles
     * const pdfFile = await prisma.pdfFile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many PdfFiles and only return the `id`
     * const pdfFileWithIdOnly = await prisma.pdfFile.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 PdfFileCreateManyAndReturnArgs>(args?: SelectSubset<T, PdfFileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfFilePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a PdfFile.
     * @param {PdfFileDeleteArgs} args - Arguments to delete one PdfFile.
     * @example
     * // Delete one PdfFile
     * const PdfFile = await prisma.pdfFile.delete({
     *   where: {
     *     // ... filter to delete one PdfFile
     *   }
     * })
     * 
     */
    delete<T extends PdfFileDeleteArgs>(args: SelectSubset<T, PdfFileDeleteArgs<ExtArgs>>): Prisma__PdfFileClient<$Result.GetResult<Prisma.$PdfFilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more PdfFiles and returns the data updated in the database.
     * @param {PdfFileUpdateManyAndReturnArgs} args - Arguments to update many PdfFiles.
     * @example
     * // Update many PdfFiles
     * const pdfFile = await prisma.pdfFile.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more PdfFiles and only return the `id`
     * const pdfFileWithIdOnly = await prisma.pdfFile.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PdfFileUpdateManyAndReturnArgs>(args: SelectSubset<T, PdfFileUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PdfFilePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PdfFile.
   * 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__PdfFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    group<T extends PdfGroupDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PdfGroupDefaultArgs<ExtArgs>>): Prisma__PdfGroupClient<$Result.GetResult<Prisma.$PdfGroupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PdfFile model
   */
  interface PdfFileFieldRefs {
    readonly id: FieldRef<"PdfFile", 'Int'>
    readonly filename: FieldRef<"PdfFile", 'String'>
    readonly pdfData: FieldRef<"PdfFile", 'Bytes'>
    readonly uploadedAt: FieldRef<"PdfFile", 'DateTime'>
    readonly groupId: FieldRef<"PdfFile", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * PdfFile findUnique
   */
  export type PdfFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * Filter, which PdfFile to fetch.
     */
    where: PdfFileWhereUniqueInput
  }

  /**
   * PdfFile findUniqueOrThrow
   */
  export type PdfFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * Filter, which PdfFile to fetch.
     */
    where: PdfFileWhereUniqueInput
  }

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

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

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

  /**
   * PdfFile create
   */
  export type PdfFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * The data needed to create a PdfFile.
     */
    data: XOR<PdfFileCreateInput, PdfFileUncheckedCreateInput>
  }

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

  /**
   * PdfFile createManyAndReturn
   */
  export type PdfFileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * The data used to create many PdfFiles.
     */
    data: PdfFileCreateManyInput | PdfFileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PdfFile update
   */
  export type PdfFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * The data needed to update a PdfFile.
     */
    data: XOR<PdfFileUpdateInput, PdfFileUncheckedUpdateInput>
    /**
     * Choose, which PdfFile to update.
     */
    where: PdfFileWhereUniqueInput
  }

  /**
   * PdfFile updateMany
   */
  export type PdfFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PdfFiles.
     */
    data: XOR<PdfFileUpdateManyMutationInput, PdfFileUncheckedUpdateManyInput>
    /**
     * Filter which PdfFiles to update
     */
    where?: PdfFileWhereInput
    /**
     * Limit how many PdfFiles to update.
     */
    limit?: number
  }

  /**
   * PdfFile updateManyAndReturn
   */
  export type PdfFileUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * The data used to update PdfFiles.
     */
    data: XOR<PdfFileUpdateManyMutationInput, PdfFileUncheckedUpdateManyInput>
    /**
     * Filter which PdfFiles to update
     */
    where?: PdfFileWhereInput
    /**
     * Limit how many PdfFiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * PdfFile upsert
   */
  export type PdfFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * The filter to search for the PdfFile to update in case it exists.
     */
    where: PdfFileWhereUniqueInput
    /**
     * In case the PdfFile found by the `where` argument doesn't exist, create a new PdfFile with this data.
     */
    create: XOR<PdfFileCreateInput, PdfFileUncheckedCreateInput>
    /**
     * In case the PdfFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PdfFileUpdateInput, PdfFileUncheckedUpdateInput>
  }

  /**
   * PdfFile delete
   */
  export type PdfFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PdfFile
     */
    select?: PdfFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PdfFile
     */
    omit?: PdfFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PdfFileInclude<ExtArgs> | null
    /**
     * Filter which PdfFile to delete.
     */
    where: PdfFileWhereUniqueInput
  }

  /**
   * PdfFile deleteMany
   */
  export type PdfFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PdfFiles to delete
     */
    where?: PdfFileWhereInput
    /**
     * Limit how many PdfFiles to delete.
     */
    limit?: number
  }

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


  /**
   * Model Payment
   */

  export type AggregatePayment = {
    _count: PaymentCountAggregateOutputType | null
    _avg: PaymentAvgAggregateOutputType | null
    _sum: PaymentSumAggregateOutputType | null
    _min: PaymentMinAggregateOutputType | null
    _max: PaymentMaxAggregateOutputType | null
  }

  export type PaymentAvgAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    npiProviderId: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    mhPaidAmount: Decimal | null
    copayment: Decimal | null
    adjustment: Decimal | null
  }

  export type PaymentSumAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    npiProviderId: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    mhPaidAmount: Decimal | null
    copayment: Decimal | null
    adjustment: Decimal | null
  }

  export type PaymentMinAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    npiProviderId: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    mhPaidAmount: Decimal | null
    copayment: Decimal | null
    adjustment: Decimal | null
    status: $Enums.PaymentStatus | null
    notes: string | null
    icn: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PaymentMaxAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    npiProviderId: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
    mhPaidAmount: Decimal | null
    copayment: Decimal | null
    adjustment: Decimal | null
    status: $Enums.PaymentStatus | null
    notes: string | null
    icn: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PaymentCountAggregateOutputType = {
    id: number
    claimId: number
    patientId: number
    userId: number
    updatedById: number
    npiProviderId: number
    totalBilled: number
    totalPaid: number
    totalAdjusted: number
    totalDue: number
    mhPaidAmount: number
    copayment: number
    adjustment: number
    status: number
    notes: number
    icn: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PaymentAvgAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    npiProviderId?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    mhPaidAmount?: true
    copayment?: true
    adjustment?: true
  }

  export type PaymentSumAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    npiProviderId?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    mhPaidAmount?: true
    copayment?: true
    adjustment?: true
  }

  export type PaymentMinAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    npiProviderId?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    mhPaidAmount?: true
    copayment?: true
    adjustment?: true
    status?: true
    notes?: true
    icn?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentMaxAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    npiProviderId?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    mhPaidAmount?: true
    copayment?: true
    adjustment?: true
    status?: true
    notes?: true
    icn?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentCountAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    npiProviderId?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    mhPaidAmount?: true
    copayment?: true
    adjustment?: true
    status?: true
    notes?: true
    icn?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PaymentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Payment to aggregate.
     */
    where?: PaymentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Payments to fetch.
     */
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PaymentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Payments 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` Payments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Payments
    **/
    _count?: true | PaymentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PaymentAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PaymentSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PaymentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PaymentMaxAggregateInputType
  }

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




  export type PaymentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithAggregationInput | PaymentOrderByWithAggregationInput[]
    by: PaymentScalarFieldEnum[] | PaymentScalarFieldEnum
    having?: PaymentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PaymentCountAggregateInputType | true
    _avg?: PaymentAvgAggregateInputType
    _sum?: PaymentSumAggregateInputType
    _min?: PaymentMinAggregateInputType
    _max?: PaymentMaxAggregateInputType
  }

  export type PaymentGroupByOutputType = {
    id: number
    claimId: number | null
    patientId: number
    userId: number
    updatedById: number | null
    npiProviderId: number | null
    totalBilled: Decimal
    totalPaid: Decimal
    totalAdjusted: Decimal
    totalDue: Decimal
    mhPaidAmount: Decimal | null
    copayment: Decimal
    adjustment: Decimal
    status: $Enums.PaymentStatus
    notes: string | null
    icn: string | null
    createdAt: Date
    updatedAt: Date
    _count: PaymentCountAggregateOutputType | null
    _avg: PaymentAvgAggregateOutputType | null
    _sum: PaymentSumAggregateOutputType | null
    _min: PaymentMinAggregateOutputType | null
    _max: PaymentMaxAggregateOutputType | null
  }

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


  export type PaymentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    npiProviderId?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    mhPaidAmount?: boolean
    copayment?: boolean
    adjustment?: boolean
    status?: boolean
    notes?: boolean
    icn?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
    serviceLineTransactions?: boolean | Payment$serviceLineTransactionsArgs<ExtArgs>
    serviceLines?: boolean | Payment$serviceLinesArgs<ExtArgs>
    commissionBatchItems?: boolean | Payment$commissionBatchItemsArgs<ExtArgs>
    _count?: boolean | PaymentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    npiProviderId?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    mhPaidAmount?: boolean
    copayment?: boolean
    adjustment?: boolean
    status?: boolean
    notes?: boolean
    icn?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    npiProviderId?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    mhPaidAmount?: boolean
    copayment?: boolean
    adjustment?: boolean
    status?: boolean
    notes?: boolean
    icn?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectScalar = {
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    npiProviderId?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: boolean
    mhPaidAmount?: boolean
    copayment?: boolean
    adjustment?: boolean
    status?: boolean
    notes?: boolean
    icn?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PaymentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "claimId" | "patientId" | "userId" | "updatedById" | "npiProviderId" | "totalBilled" | "totalPaid" | "totalAdjusted" | "totalDue" | "mhPaidAmount" | "copayment" | "adjustment" | "status" | "notes" | "icn" | "createdAt" | "updatedAt", ExtArgs["result"]["payment"]>
  export type PaymentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
    serviceLineTransactions?: boolean | Payment$serviceLineTransactionsArgs<ExtArgs>
    serviceLines?: boolean | Payment$serviceLinesArgs<ExtArgs>
    commissionBatchItems?: boolean | Payment$commissionBatchItemsArgs<ExtArgs>
    _count?: boolean | PaymentCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PaymentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
  }
  export type PaymentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<ExtArgs>
    npiProvider?: boolean | Payment$npiProviderArgs<ExtArgs>
  }

  export type $PaymentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Payment"
    objects: {
      claim: Prisma.$ClaimPayload<ExtArgs> | null
      patient: Prisma.$PatientPayload<ExtArgs>
      updatedBy: Prisma.$UserPayload<ExtArgs> | null
      npiProvider: Prisma.$NpiProviderPayload<ExtArgs> | null
      serviceLineTransactions: Prisma.$ServiceLineTransactionPayload<ExtArgs>[]
      serviceLines: Prisma.$ServiceLinePayload<ExtArgs>[]
      commissionBatchItems: Prisma.$CommissionBatchItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      claimId: number | null
      patientId: number
      userId: number
      updatedById: number | null
      npiProviderId: number | null
      totalBilled: Prisma.Decimal
      totalPaid: Prisma.Decimal
      totalAdjusted: Prisma.Decimal
      totalDue: Prisma.Decimal
      mhPaidAmount: Prisma.Decimal | null
      copayment: Prisma.Decimal
      adjustment: Prisma.Decimal
      status: $Enums.PaymentStatus
      notes: string | null
      icn: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["payment"]>
    composites: {}
  }

  type PaymentGetPayload<S extends boolean | null | undefined | PaymentDefaultArgs> = $Result.GetResult<Prisma.$PaymentPayload, S>

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

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

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

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

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

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

    /**
     * Create a Payment.
     * @param {PaymentCreateArgs} args - Arguments to create a Payment.
     * @example
     * // Create one Payment
     * const Payment = await prisma.payment.create({
     *   data: {
     *     // ... data to create a Payment
     *   }
     * })
     * 
     */
    create<T extends PaymentCreateArgs>(args: SelectSubset<T, PaymentCreateArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Payments and returns the data saved in the database.
     * @param {PaymentCreateManyAndReturnArgs} args - Arguments to create many Payments.
     * @example
     * // Create many Payments
     * const payment = await prisma.payment.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Payments and only return the `id`
     * const paymentWithIdOnly = await prisma.payment.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 PaymentCreateManyAndReturnArgs>(args?: SelectSubset<T, PaymentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Payment.
     * @param {PaymentDeleteArgs} args - Arguments to delete one Payment.
     * @example
     * // Delete one Payment
     * const Payment = await prisma.payment.delete({
     *   where: {
     *     // ... filter to delete one Payment
     *   }
     * })
     * 
     */
    delete<T extends PaymentDeleteArgs>(args: SelectSubset<T, PaymentDeleteArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more Payments and returns the data updated in the database.
     * @param {PaymentUpdateManyAndReturnArgs} args - Arguments to update many Payments.
     * @example
     * // Update many Payments
     * const payment = await prisma.payment.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Payments and only return the `id`
     * const paymentWithIdOnly = await prisma.payment.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PaymentUpdateManyAndReturnArgs>(args: SelectSubset<T, PaymentUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Payment.
   * 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__PaymentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    claim<T extends Payment$claimArgs<ExtArgs> = {}>(args?: Subset<T, Payment$claimArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    updatedBy<T extends Payment$updatedByArgs<ExtArgs> = {}>(args?: Subset<T, Payment$updatedByArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    npiProvider<T extends Payment$npiProviderArgs<ExtArgs> = {}>(args?: Subset<T, Payment$npiProviderArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    serviceLineTransactions<T extends Payment$serviceLineTransactionsArgs<ExtArgs> = {}>(args?: Subset<T, Payment$serviceLineTransactionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    serviceLines<T extends Payment$serviceLinesArgs<ExtArgs> = {}>(args?: Subset<T, Payment$serviceLinesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    commissionBatchItems<T extends Payment$commissionBatchItemsArgs<ExtArgs> = {}>(args?: Subset<T, Payment$commissionBatchItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Payment model
   */
  interface PaymentFieldRefs {
    readonly id: FieldRef<"Payment", 'Int'>
    readonly claimId: FieldRef<"Payment", 'Int'>
    readonly patientId: FieldRef<"Payment", 'Int'>
    readonly userId: FieldRef<"Payment", 'Int'>
    readonly updatedById: FieldRef<"Payment", 'Int'>
    readonly npiProviderId: FieldRef<"Payment", 'Int'>
    readonly totalBilled: FieldRef<"Payment", 'Decimal'>
    readonly totalPaid: FieldRef<"Payment", 'Decimal'>
    readonly totalAdjusted: FieldRef<"Payment", 'Decimal'>
    readonly totalDue: FieldRef<"Payment", 'Decimal'>
    readonly mhPaidAmount: FieldRef<"Payment", 'Decimal'>
    readonly copayment: FieldRef<"Payment", 'Decimal'>
    readonly adjustment: FieldRef<"Payment", 'Decimal'>
    readonly status: FieldRef<"Payment", 'PaymentStatus'>
    readonly notes: FieldRef<"Payment", 'String'>
    readonly icn: FieldRef<"Payment", 'String'>
    readonly createdAt: FieldRef<"Payment", 'DateTime'>
    readonly updatedAt: FieldRef<"Payment", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Payment findUnique
   */
  export type PaymentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment findUniqueOrThrow
   */
  export type PaymentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where: PaymentWhereUniqueInput
  }

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

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

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

  /**
   * Payment create
   */
  export type PaymentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The data needed to create a Payment.
     */
    data: XOR<PaymentCreateInput, PaymentUncheckedCreateInput>
  }

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

  /**
   * Payment createManyAndReturn
   */
  export type PaymentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * The data used to create many Payments.
     */
    data: PaymentCreateManyInput | PaymentCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Payment update
   */
  export type PaymentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The data needed to update a Payment.
     */
    data: XOR<PaymentUpdateInput, PaymentUncheckedUpdateInput>
    /**
     * Choose, which Payment to update.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment updateMany
   */
  export type PaymentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Payments.
     */
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyInput>
    /**
     * Filter which Payments to update
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to update.
     */
    limit?: number
  }

  /**
   * Payment updateManyAndReturn
   */
  export type PaymentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * The data used to update Payments.
     */
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyInput>
    /**
     * Filter which Payments to update
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Payment upsert
   */
  export type PaymentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The filter to search for the Payment to update in case it exists.
     */
    where: PaymentWhereUniqueInput
    /**
     * In case the Payment found by the `where` argument doesn't exist, create a new Payment with this data.
     */
    create: XOR<PaymentCreateInput, PaymentUncheckedCreateInput>
    /**
     * In case the Payment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PaymentUpdateInput, PaymentUncheckedUpdateInput>
  }

  /**
   * Payment delete
   */
  export type PaymentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter which Payment to delete.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment deleteMany
   */
  export type PaymentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Payments to delete
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to delete.
     */
    limit?: number
  }

  /**
   * Payment.claim
   */
  export type Payment$claimArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Claim
     */
    select?: ClaimSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Claim
     */
    omit?: ClaimOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ClaimInclude<ExtArgs> | null
    where?: ClaimWhereInput
  }

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

  /**
   * Payment.npiProvider
   */
  export type Payment$npiProviderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NpiProvider
     */
    select?: NpiProviderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the NpiProvider
     */
    omit?: NpiProviderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NpiProviderInclude<ExtArgs> | null
    where?: NpiProviderWhereInput
  }

  /**
   * Payment.serviceLineTransactions
   */
  export type Payment$serviceLineTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    where?: ServiceLineTransactionWhereInput
    orderBy?: ServiceLineTransactionOrderByWithRelationInput | ServiceLineTransactionOrderByWithRelationInput[]
    cursor?: ServiceLineTransactionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ServiceLineTransactionScalarFieldEnum | ServiceLineTransactionScalarFieldEnum[]
  }

  /**
   * Payment.serviceLines
   */
  export type Payment$serviceLinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLine
     */
    select?: ServiceLineSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLine
     */
    omit?: ServiceLineOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineInclude<ExtArgs> | null
    where?: ServiceLineWhereInput
    orderBy?: ServiceLineOrderByWithRelationInput | ServiceLineOrderByWithRelationInput[]
    cursor?: ServiceLineWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ServiceLineScalarFieldEnum | ServiceLineScalarFieldEnum[]
  }

  /**
   * Payment.commissionBatchItems
   */
  export type Payment$commissionBatchItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    where?: CommissionBatchItemWhereInput
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    cursor?: CommissionBatchItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommissionBatchItemScalarFieldEnum | CommissionBatchItemScalarFieldEnum[]
  }

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


  /**
   * Model ServiceLineTransaction
   */

  export type AggregateServiceLineTransaction = {
    _count: ServiceLineTransactionCountAggregateOutputType | null
    _avg: ServiceLineTransactionAvgAggregateOutputType | null
    _sum: ServiceLineTransactionSumAggregateOutputType | null
    _min: ServiceLineTransactionMinAggregateOutputType | null
    _max: ServiceLineTransactionMaxAggregateOutputType | null
  }

  export type ServiceLineTransactionAvgAggregateOutputType = {
    id: number | null
    paymentId: number | null
    serviceLineId: number | null
    paidAmount: Decimal | null
    adjustedAmount: Decimal | null
  }

  export type ServiceLineTransactionSumAggregateOutputType = {
    id: number | null
    paymentId: number | null
    serviceLineId: number | null
    paidAmount: Decimal | null
    adjustedAmount: Decimal | null
  }

  export type ServiceLineTransactionMinAggregateOutputType = {
    id: number | null
    paymentId: number | null
    serviceLineId: number | null
    transactionId: string | null
    paidAmount: Decimal | null
    adjustedAmount: Decimal | null
    method: $Enums.PaymentMethod | null
    receivedDate: Date | null
    payerName: string | null
    notes: string | null
    createdAt: Date | null
  }

  export type ServiceLineTransactionMaxAggregateOutputType = {
    id: number | null
    paymentId: number | null
    serviceLineId: number | null
    transactionId: string | null
    paidAmount: Decimal | null
    adjustedAmount: Decimal | null
    method: $Enums.PaymentMethod | null
    receivedDate: Date | null
    payerName: string | null
    notes: string | null
    createdAt: Date | null
  }

  export type ServiceLineTransactionCountAggregateOutputType = {
    id: number
    paymentId: number
    serviceLineId: number
    transactionId: number
    paidAmount: number
    adjustedAmount: number
    method: number
    receivedDate: number
    payerName: number
    notes: number
    createdAt: number
    _all: number
  }


  export type ServiceLineTransactionAvgAggregateInputType = {
    id?: true
    paymentId?: true
    serviceLineId?: true
    paidAmount?: true
    adjustedAmount?: true
  }

  export type ServiceLineTransactionSumAggregateInputType = {
    id?: true
    paymentId?: true
    serviceLineId?: true
    paidAmount?: true
    adjustedAmount?: true
  }

  export type ServiceLineTransactionMinAggregateInputType = {
    id?: true
    paymentId?: true
    serviceLineId?: true
    transactionId?: true
    paidAmount?: true
    adjustedAmount?: true
    method?: true
    receivedDate?: true
    payerName?: true
    notes?: true
    createdAt?: true
  }

  export type ServiceLineTransactionMaxAggregateInputType = {
    id?: true
    paymentId?: true
    serviceLineId?: true
    transactionId?: true
    paidAmount?: true
    adjustedAmount?: true
    method?: true
    receivedDate?: true
    payerName?: true
    notes?: true
    createdAt?: true
  }

  export type ServiceLineTransactionCountAggregateInputType = {
    id?: true
    paymentId?: true
    serviceLineId?: true
    transactionId?: true
    paidAmount?: true
    adjustedAmount?: true
    method?: true
    receivedDate?: true
    payerName?: true
    notes?: true
    createdAt?: true
    _all?: true
  }

  export type ServiceLineTransactionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ServiceLineTransaction to aggregate.
     */
    where?: ServiceLineTransactionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ServiceLineTransactions to fetch.
     */
    orderBy?: ServiceLineTransactionOrderByWithRelationInput | ServiceLineTransactionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ServiceLineTransactionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ServiceLineTransactions 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` ServiceLineTransactions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ServiceLineTransactions
    **/
    _count?: true | ServiceLineTransactionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ServiceLineTransactionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ServiceLineTransactionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ServiceLineTransactionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ServiceLineTransactionMaxAggregateInputType
  }

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




  export type ServiceLineTransactionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ServiceLineTransactionWhereInput
    orderBy?: ServiceLineTransactionOrderByWithAggregationInput | ServiceLineTransactionOrderByWithAggregationInput[]
    by: ServiceLineTransactionScalarFieldEnum[] | ServiceLineTransactionScalarFieldEnum
    having?: ServiceLineTransactionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ServiceLineTransactionCountAggregateInputType | true
    _avg?: ServiceLineTransactionAvgAggregateInputType
    _sum?: ServiceLineTransactionSumAggregateInputType
    _min?: ServiceLineTransactionMinAggregateInputType
    _max?: ServiceLineTransactionMaxAggregateInputType
  }

  export type ServiceLineTransactionGroupByOutputType = {
    id: number
    paymentId: number
    serviceLineId: number
    transactionId: string | null
    paidAmount: Decimal
    adjustedAmount: Decimal
    method: $Enums.PaymentMethod
    receivedDate: Date
    payerName: string | null
    notes: string | null
    createdAt: Date
    _count: ServiceLineTransactionCountAggregateOutputType | null
    _avg: ServiceLineTransactionAvgAggregateOutputType | null
    _sum: ServiceLineTransactionSumAggregateOutputType | null
    _min: ServiceLineTransactionMinAggregateOutputType | null
    _max: ServiceLineTransactionMaxAggregateOutputType | null
  }

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


  export type ServiceLineTransactionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    paymentId?: boolean
    serviceLineId?: boolean
    transactionId?: boolean
    paidAmount?: boolean
    adjustedAmount?: boolean
    method?: boolean
    receivedDate?: boolean
    payerName?: boolean
    notes?: boolean
    createdAt?: boolean
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLineTransaction"]>

  export type ServiceLineTransactionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    paymentId?: boolean
    serviceLineId?: boolean
    transactionId?: boolean
    paidAmount?: boolean
    adjustedAmount?: boolean
    method?: boolean
    receivedDate?: boolean
    payerName?: boolean
    notes?: boolean
    createdAt?: boolean
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLineTransaction"]>

  export type ServiceLineTransactionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    paymentId?: boolean
    serviceLineId?: boolean
    transactionId?: boolean
    paidAmount?: boolean
    adjustedAmount?: boolean
    method?: boolean
    receivedDate?: boolean
    payerName?: boolean
    notes?: boolean
    createdAt?: boolean
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["serviceLineTransaction"]>

  export type ServiceLineTransactionSelectScalar = {
    id?: boolean
    paymentId?: boolean
    serviceLineId?: boolean
    transactionId?: boolean
    paidAmount?: boolean
    adjustedAmount?: boolean
    method?: boolean
    receivedDate?: boolean
    payerName?: boolean
    notes?: boolean
    createdAt?: boolean
  }

  export type ServiceLineTransactionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "paymentId" | "serviceLineId" | "transactionId" | "paidAmount" | "adjustedAmount" | "method" | "receivedDate" | "payerName" | "notes" | "createdAt", ExtArgs["result"]["serviceLineTransaction"]>
  export type ServiceLineTransactionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }
  export type ServiceLineTransactionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }
  export type ServiceLineTransactionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
    serviceLine?: boolean | ServiceLineDefaultArgs<ExtArgs>
  }

  export type $ServiceLineTransactionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ServiceLineTransaction"
    objects: {
      payment: Prisma.$PaymentPayload<ExtArgs>
      serviceLine: Prisma.$ServiceLinePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      paymentId: number
      serviceLineId: number
      transactionId: string | null
      paidAmount: Prisma.Decimal
      adjustedAmount: Prisma.Decimal
      method: $Enums.PaymentMethod
      receivedDate: Date
      payerName: string | null
      notes: string | null
      createdAt: Date
    }, ExtArgs["result"]["serviceLineTransaction"]>
    composites: {}
  }

  type ServiceLineTransactionGetPayload<S extends boolean | null | undefined | ServiceLineTransactionDefaultArgs> = $Result.GetResult<Prisma.$ServiceLineTransactionPayload, S>

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

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

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

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

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

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

    /**
     * Create a ServiceLineTransaction.
     * @param {ServiceLineTransactionCreateArgs} args - Arguments to create a ServiceLineTransaction.
     * @example
     * // Create one ServiceLineTransaction
     * const ServiceLineTransaction = await prisma.serviceLineTransaction.create({
     *   data: {
     *     // ... data to create a ServiceLineTransaction
     *   }
     * })
     * 
     */
    create<T extends ServiceLineTransactionCreateArgs>(args: SelectSubset<T, ServiceLineTransactionCreateArgs<ExtArgs>>): Prisma__ServiceLineTransactionClient<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ServiceLineTransactions and returns the data saved in the database.
     * @param {ServiceLineTransactionCreateManyAndReturnArgs} args - Arguments to create many ServiceLineTransactions.
     * @example
     * // Create many ServiceLineTransactions
     * const serviceLineTransaction = await prisma.serviceLineTransaction.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ServiceLineTransactions and only return the `id`
     * const serviceLineTransactionWithIdOnly = await prisma.serviceLineTransaction.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 ServiceLineTransactionCreateManyAndReturnArgs>(args?: SelectSubset<T, ServiceLineTransactionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ServiceLineTransaction.
     * @param {ServiceLineTransactionDeleteArgs} args - Arguments to delete one ServiceLineTransaction.
     * @example
     * // Delete one ServiceLineTransaction
     * const ServiceLineTransaction = await prisma.serviceLineTransaction.delete({
     *   where: {
     *     // ... filter to delete one ServiceLineTransaction
     *   }
     * })
     * 
     */
    delete<T extends ServiceLineTransactionDeleteArgs>(args: SelectSubset<T, ServiceLineTransactionDeleteArgs<ExtArgs>>): Prisma__ServiceLineTransactionClient<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more ServiceLineTransactions and returns the data updated in the database.
     * @param {ServiceLineTransactionUpdateManyAndReturnArgs} args - Arguments to update many ServiceLineTransactions.
     * @example
     * // Update many ServiceLineTransactions
     * const serviceLineTransaction = await prisma.serviceLineTransaction.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ServiceLineTransactions and only return the `id`
     * const serviceLineTransactionWithIdOnly = await prisma.serviceLineTransaction.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ServiceLineTransactionUpdateManyAndReturnArgs>(args: SelectSubset<T, ServiceLineTransactionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ServiceLineTransactionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ServiceLineTransaction.
   * 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__ServiceLineTransactionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    payment<T extends PaymentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PaymentDefaultArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    serviceLine<T extends ServiceLineDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ServiceLineDefaultArgs<ExtArgs>>): Prisma__ServiceLineClient<$Result.GetResult<Prisma.$ServiceLinePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ServiceLineTransaction model
   */
  interface ServiceLineTransactionFieldRefs {
    readonly id: FieldRef<"ServiceLineTransaction", 'Int'>
    readonly paymentId: FieldRef<"ServiceLineTransaction", 'Int'>
    readonly serviceLineId: FieldRef<"ServiceLineTransaction", 'Int'>
    readonly transactionId: FieldRef<"ServiceLineTransaction", 'String'>
    readonly paidAmount: FieldRef<"ServiceLineTransaction", 'Decimal'>
    readonly adjustedAmount: FieldRef<"ServiceLineTransaction", 'Decimal'>
    readonly method: FieldRef<"ServiceLineTransaction", 'PaymentMethod'>
    readonly receivedDate: FieldRef<"ServiceLineTransaction", 'DateTime'>
    readonly payerName: FieldRef<"ServiceLineTransaction", 'String'>
    readonly notes: FieldRef<"ServiceLineTransaction", 'String'>
    readonly createdAt: FieldRef<"ServiceLineTransaction", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * ServiceLineTransaction findUnique
   */
  export type ServiceLineTransactionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * Filter, which ServiceLineTransaction to fetch.
     */
    where: ServiceLineTransactionWhereUniqueInput
  }

  /**
   * ServiceLineTransaction findUniqueOrThrow
   */
  export type ServiceLineTransactionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * Filter, which ServiceLineTransaction to fetch.
     */
    where: ServiceLineTransactionWhereUniqueInput
  }

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

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

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

  /**
   * ServiceLineTransaction create
   */
  export type ServiceLineTransactionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * The data needed to create a ServiceLineTransaction.
     */
    data: XOR<ServiceLineTransactionCreateInput, ServiceLineTransactionUncheckedCreateInput>
  }

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

  /**
   * ServiceLineTransaction createManyAndReturn
   */
  export type ServiceLineTransactionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * The data used to create many ServiceLineTransactions.
     */
    data: ServiceLineTransactionCreateManyInput | ServiceLineTransactionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ServiceLineTransaction update
   */
  export type ServiceLineTransactionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * The data needed to update a ServiceLineTransaction.
     */
    data: XOR<ServiceLineTransactionUpdateInput, ServiceLineTransactionUncheckedUpdateInput>
    /**
     * Choose, which ServiceLineTransaction to update.
     */
    where: ServiceLineTransactionWhereUniqueInput
  }

  /**
   * ServiceLineTransaction updateMany
   */
  export type ServiceLineTransactionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ServiceLineTransactions.
     */
    data: XOR<ServiceLineTransactionUpdateManyMutationInput, ServiceLineTransactionUncheckedUpdateManyInput>
    /**
     * Filter which ServiceLineTransactions to update
     */
    where?: ServiceLineTransactionWhereInput
    /**
     * Limit how many ServiceLineTransactions to update.
     */
    limit?: number
  }

  /**
   * ServiceLineTransaction updateManyAndReturn
   */
  export type ServiceLineTransactionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * The data used to update ServiceLineTransactions.
     */
    data: XOR<ServiceLineTransactionUpdateManyMutationInput, ServiceLineTransactionUncheckedUpdateManyInput>
    /**
     * Filter which ServiceLineTransactions to update
     */
    where?: ServiceLineTransactionWhereInput
    /**
     * Limit how many ServiceLineTransactions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ServiceLineTransaction upsert
   */
  export type ServiceLineTransactionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * The filter to search for the ServiceLineTransaction to update in case it exists.
     */
    where: ServiceLineTransactionWhereUniqueInput
    /**
     * In case the ServiceLineTransaction found by the `where` argument doesn't exist, create a new ServiceLineTransaction with this data.
     */
    create: XOR<ServiceLineTransactionCreateInput, ServiceLineTransactionUncheckedCreateInput>
    /**
     * In case the ServiceLineTransaction was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ServiceLineTransactionUpdateInput, ServiceLineTransactionUncheckedUpdateInput>
  }

  /**
   * ServiceLineTransaction delete
   */
  export type ServiceLineTransactionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ServiceLineTransaction
     */
    select?: ServiceLineTransactionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ServiceLineTransaction
     */
    omit?: ServiceLineTransactionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ServiceLineTransactionInclude<ExtArgs> | null
    /**
     * Filter which ServiceLineTransaction to delete.
     */
    where: ServiceLineTransactionWhereUniqueInput
  }

  /**
   * ServiceLineTransaction deleteMany
   */
  export type ServiceLineTransactionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ServiceLineTransactions to delete
     */
    where?: ServiceLineTransactionWhereInput
    /**
     * Limit how many ServiceLineTransactions to delete.
     */
    limit?: number
  }

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


  /**
   * Model DatabaseBackup
   */

  export type AggregateDatabaseBackup = {
    _count: DatabaseBackupCountAggregateOutputType | null
    _avg: DatabaseBackupAvgAggregateOutputType | null
    _sum: DatabaseBackupSumAggregateOutputType | null
    _min: DatabaseBackupMinAggregateOutputType | null
    _max: DatabaseBackupMaxAggregateOutputType | null
  }

  export type DatabaseBackupAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type DatabaseBackupSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type DatabaseBackupMinAggregateOutputType = {
    id: number | null
    userId: number | null
    createdAt: Date | null
  }

  export type DatabaseBackupMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    createdAt: Date | null
  }

  export type DatabaseBackupCountAggregateOutputType = {
    id: number
    userId: number
    createdAt: number
    _all: number
  }


  export type DatabaseBackupAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type DatabaseBackupSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type DatabaseBackupMinAggregateInputType = {
    id?: true
    userId?: true
    createdAt?: true
  }

  export type DatabaseBackupMaxAggregateInputType = {
    id?: true
    userId?: true
    createdAt?: true
  }

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

  export type DatabaseBackupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which DatabaseBackup to aggregate.
     */
    where?: DatabaseBackupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of DatabaseBackups to fetch.
     */
    orderBy?: DatabaseBackupOrderByWithRelationInput | DatabaseBackupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: DatabaseBackupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` DatabaseBackups 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` DatabaseBackups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned DatabaseBackups
    **/
    _count?: true | DatabaseBackupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DatabaseBackupAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DatabaseBackupSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DatabaseBackupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DatabaseBackupMaxAggregateInputType
  }

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




  export type DatabaseBackupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: DatabaseBackupWhereInput
    orderBy?: DatabaseBackupOrderByWithAggregationInput | DatabaseBackupOrderByWithAggregationInput[]
    by: DatabaseBackupScalarFieldEnum[] | DatabaseBackupScalarFieldEnum
    having?: DatabaseBackupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DatabaseBackupCountAggregateInputType | true
    _avg?: DatabaseBackupAvgAggregateInputType
    _sum?: DatabaseBackupSumAggregateInputType
    _min?: DatabaseBackupMinAggregateInputType
    _max?: DatabaseBackupMaxAggregateInputType
  }

  export type DatabaseBackupGroupByOutputType = {
    id: number
    userId: number
    createdAt: Date
    _count: DatabaseBackupCountAggregateOutputType | null
    _avg: DatabaseBackupAvgAggregateOutputType | null
    _sum: DatabaseBackupSumAggregateOutputType | null
    _min: DatabaseBackupMinAggregateOutputType | null
    _max: DatabaseBackupMaxAggregateOutputType | null
  }

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


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

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

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

  export type DatabaseBackupSelectScalar = {
    id?: boolean
    userId?: boolean
    createdAt?: boolean
  }

  export type DatabaseBackupOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "createdAt", ExtArgs["result"]["databaseBackup"]>
  export type DatabaseBackupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type DatabaseBackupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type DatabaseBackupIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $DatabaseBackupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "DatabaseBackup"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      createdAt: Date
    }, ExtArgs["result"]["databaseBackup"]>
    composites: {}
  }

  type DatabaseBackupGetPayload<S extends boolean | null | undefined | DatabaseBackupDefaultArgs> = $Result.GetResult<Prisma.$DatabaseBackupPayload, S>

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

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

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

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

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

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

    /**
     * Create a DatabaseBackup.
     * @param {DatabaseBackupCreateArgs} args - Arguments to create a DatabaseBackup.
     * @example
     * // Create one DatabaseBackup
     * const DatabaseBackup = await prisma.databaseBackup.create({
     *   data: {
     *     // ... data to create a DatabaseBackup
     *   }
     * })
     * 
     */
    create<T extends DatabaseBackupCreateArgs>(args: SelectSubset<T, DatabaseBackupCreateArgs<ExtArgs>>): Prisma__DatabaseBackupClient<$Result.GetResult<Prisma.$DatabaseBackupPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many DatabaseBackups and returns the data saved in the database.
     * @param {DatabaseBackupCreateManyAndReturnArgs} args - Arguments to create many DatabaseBackups.
     * @example
     * // Create many DatabaseBackups
     * const databaseBackup = await prisma.databaseBackup.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many DatabaseBackups and only return the `id`
     * const databaseBackupWithIdOnly = await prisma.databaseBackup.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 DatabaseBackupCreateManyAndReturnArgs>(args?: SelectSubset<T, DatabaseBackupCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DatabaseBackupPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a DatabaseBackup.
     * @param {DatabaseBackupDeleteArgs} args - Arguments to delete one DatabaseBackup.
     * @example
     * // Delete one DatabaseBackup
     * const DatabaseBackup = await prisma.databaseBackup.delete({
     *   where: {
     *     // ... filter to delete one DatabaseBackup
     *   }
     * })
     * 
     */
    delete<T extends DatabaseBackupDeleteArgs>(args: SelectSubset<T, DatabaseBackupDeleteArgs<ExtArgs>>): Prisma__DatabaseBackupClient<$Result.GetResult<Prisma.$DatabaseBackupPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more DatabaseBackups and returns the data updated in the database.
     * @param {DatabaseBackupUpdateManyAndReturnArgs} args - Arguments to update many DatabaseBackups.
     * @example
     * // Update many DatabaseBackups
     * const databaseBackup = await prisma.databaseBackup.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more DatabaseBackups and only return the `id`
     * const databaseBackupWithIdOnly = await prisma.databaseBackup.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends DatabaseBackupUpdateManyAndReturnArgs>(args: SelectSubset<T, DatabaseBackupUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DatabaseBackupPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for DatabaseBackup.
   * 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__DatabaseBackupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the DatabaseBackup model
   */
  interface DatabaseBackupFieldRefs {
    readonly id: FieldRef<"DatabaseBackup", 'Int'>
    readonly userId: FieldRef<"DatabaseBackup", 'Int'>
    readonly createdAt: FieldRef<"DatabaseBackup", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * DatabaseBackup findUnique
   */
  export type DatabaseBackupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * Filter, which DatabaseBackup to fetch.
     */
    where: DatabaseBackupWhereUniqueInput
  }

  /**
   * DatabaseBackup findUniqueOrThrow
   */
  export type DatabaseBackupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * Filter, which DatabaseBackup to fetch.
     */
    where: DatabaseBackupWhereUniqueInput
  }

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

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

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

  /**
   * DatabaseBackup create
   */
  export type DatabaseBackupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * The data needed to create a DatabaseBackup.
     */
    data: XOR<DatabaseBackupCreateInput, DatabaseBackupUncheckedCreateInput>
  }

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

  /**
   * DatabaseBackup createManyAndReturn
   */
  export type DatabaseBackupCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * The data used to create many DatabaseBackups.
     */
    data: DatabaseBackupCreateManyInput | DatabaseBackupCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * DatabaseBackup update
   */
  export type DatabaseBackupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * The data needed to update a DatabaseBackup.
     */
    data: XOR<DatabaseBackupUpdateInput, DatabaseBackupUncheckedUpdateInput>
    /**
     * Choose, which DatabaseBackup to update.
     */
    where: DatabaseBackupWhereUniqueInput
  }

  /**
   * DatabaseBackup updateMany
   */
  export type DatabaseBackupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update DatabaseBackups.
     */
    data: XOR<DatabaseBackupUpdateManyMutationInput, DatabaseBackupUncheckedUpdateManyInput>
    /**
     * Filter which DatabaseBackups to update
     */
    where?: DatabaseBackupWhereInput
    /**
     * Limit how many DatabaseBackups to update.
     */
    limit?: number
  }

  /**
   * DatabaseBackup updateManyAndReturn
   */
  export type DatabaseBackupUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * The data used to update DatabaseBackups.
     */
    data: XOR<DatabaseBackupUpdateManyMutationInput, DatabaseBackupUncheckedUpdateManyInput>
    /**
     * Filter which DatabaseBackups to update
     */
    where?: DatabaseBackupWhereInput
    /**
     * Limit how many DatabaseBackups to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * DatabaseBackup upsert
   */
  export type DatabaseBackupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * The filter to search for the DatabaseBackup to update in case it exists.
     */
    where: DatabaseBackupWhereUniqueInput
    /**
     * In case the DatabaseBackup found by the `where` argument doesn't exist, create a new DatabaseBackup with this data.
     */
    create: XOR<DatabaseBackupCreateInput, DatabaseBackupUncheckedCreateInput>
    /**
     * In case the DatabaseBackup was found with the provided `where` argument, update it with this data.
     */
    update: XOR<DatabaseBackupUpdateInput, DatabaseBackupUncheckedUpdateInput>
  }

  /**
   * DatabaseBackup delete
   */
  export type DatabaseBackupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DatabaseBackup
     */
    select?: DatabaseBackupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DatabaseBackup
     */
    omit?: DatabaseBackupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DatabaseBackupInclude<ExtArgs> | null
    /**
     * Filter which DatabaseBackup to delete.
     */
    where: DatabaseBackupWhereUniqueInput
  }

  /**
   * DatabaseBackup deleteMany
   */
  export type DatabaseBackupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which DatabaseBackups to delete
     */
    where?: DatabaseBackupWhereInput
    /**
     * Limit how many DatabaseBackups to delete.
     */
    limit?: number
  }

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


  /**
   * Model BackupDestination
   */

  export type AggregateBackupDestination = {
    _count: BackupDestinationCountAggregateOutputType | null
    _avg: BackupDestinationAvgAggregateOutputType | null
    _sum: BackupDestinationSumAggregateOutputType | null
    _min: BackupDestinationMinAggregateOutputType | null
    _max: BackupDestinationMaxAggregateOutputType | null
  }

  export type BackupDestinationAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type BackupDestinationSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type BackupDestinationMinAggregateOutputType = {
    id: number | null
    userId: number | null
    path: string | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type BackupDestinationMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    path: string | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type BackupDestinationCountAggregateOutputType = {
    id: number
    userId: number
    path: number
    isActive: number
    createdAt: number
    _all: number
  }


  export type BackupDestinationAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type BackupDestinationSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type BackupDestinationMinAggregateInputType = {
    id?: true
    userId?: true
    path?: true
    isActive?: true
    createdAt?: true
  }

  export type BackupDestinationMaxAggregateInputType = {
    id?: true
    userId?: true
    path?: true
    isActive?: true
    createdAt?: true
  }

  export type BackupDestinationCountAggregateInputType = {
    id?: true
    userId?: true
    path?: true
    isActive?: true
    createdAt?: true
    _all?: true
  }

  export type BackupDestinationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BackupDestination to aggregate.
     */
    where?: BackupDestinationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BackupDestinations to fetch.
     */
    orderBy?: BackupDestinationOrderByWithRelationInput | BackupDestinationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BackupDestinationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BackupDestinations 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` BackupDestinations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned BackupDestinations
    **/
    _count?: true | BackupDestinationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: BackupDestinationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: BackupDestinationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BackupDestinationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BackupDestinationMaxAggregateInputType
  }

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




  export type BackupDestinationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BackupDestinationWhereInput
    orderBy?: BackupDestinationOrderByWithAggregationInput | BackupDestinationOrderByWithAggregationInput[]
    by: BackupDestinationScalarFieldEnum[] | BackupDestinationScalarFieldEnum
    having?: BackupDestinationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BackupDestinationCountAggregateInputType | true
    _avg?: BackupDestinationAvgAggregateInputType
    _sum?: BackupDestinationSumAggregateInputType
    _min?: BackupDestinationMinAggregateInputType
    _max?: BackupDestinationMaxAggregateInputType
  }

  export type BackupDestinationGroupByOutputType = {
    id: number
    userId: number
    path: string
    isActive: boolean
    createdAt: Date
    _count: BackupDestinationCountAggregateOutputType | null
    _avg: BackupDestinationAvgAggregateOutputType | null
    _sum: BackupDestinationSumAggregateOutputType | null
    _min: BackupDestinationMinAggregateOutputType | null
    _max: BackupDestinationMaxAggregateOutputType | null
  }

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


  export type BackupDestinationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    path?: boolean
    isActive?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["backupDestination"]>

  export type BackupDestinationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    path?: boolean
    isActive?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["backupDestination"]>

  export type BackupDestinationSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    path?: boolean
    isActive?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["backupDestination"]>

  export type BackupDestinationSelectScalar = {
    id?: boolean
    userId?: boolean
    path?: boolean
    isActive?: boolean
    createdAt?: boolean
  }

  export type BackupDestinationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "path" | "isActive" | "createdAt", ExtArgs["result"]["backupDestination"]>
  export type BackupDestinationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type BackupDestinationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type BackupDestinationIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $BackupDestinationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "BackupDestination"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      path: string
      isActive: boolean
      createdAt: Date
    }, ExtArgs["result"]["backupDestination"]>
    composites: {}
  }

  type BackupDestinationGetPayload<S extends boolean | null | undefined | BackupDestinationDefaultArgs> = $Result.GetResult<Prisma.$BackupDestinationPayload, S>

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

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

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

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

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

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

    /**
     * Create a BackupDestination.
     * @param {BackupDestinationCreateArgs} args - Arguments to create a BackupDestination.
     * @example
     * // Create one BackupDestination
     * const BackupDestination = await prisma.backupDestination.create({
     *   data: {
     *     // ... data to create a BackupDestination
     *   }
     * })
     * 
     */
    create<T extends BackupDestinationCreateArgs>(args: SelectSubset<T, BackupDestinationCreateArgs<ExtArgs>>): Prisma__BackupDestinationClient<$Result.GetResult<Prisma.$BackupDestinationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many BackupDestinations and returns the data saved in the database.
     * @param {BackupDestinationCreateManyAndReturnArgs} args - Arguments to create many BackupDestinations.
     * @example
     * // Create many BackupDestinations
     * const backupDestination = await prisma.backupDestination.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many BackupDestinations and only return the `id`
     * const backupDestinationWithIdOnly = await prisma.backupDestination.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 BackupDestinationCreateManyAndReturnArgs>(args?: SelectSubset<T, BackupDestinationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BackupDestinationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a BackupDestination.
     * @param {BackupDestinationDeleteArgs} args - Arguments to delete one BackupDestination.
     * @example
     * // Delete one BackupDestination
     * const BackupDestination = await prisma.backupDestination.delete({
     *   where: {
     *     // ... filter to delete one BackupDestination
     *   }
     * })
     * 
     */
    delete<T extends BackupDestinationDeleteArgs>(args: SelectSubset<T, BackupDestinationDeleteArgs<ExtArgs>>): Prisma__BackupDestinationClient<$Result.GetResult<Prisma.$BackupDestinationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more BackupDestinations and returns the data updated in the database.
     * @param {BackupDestinationUpdateManyAndReturnArgs} args - Arguments to update many BackupDestinations.
     * @example
     * // Update many BackupDestinations
     * const backupDestination = await prisma.backupDestination.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more BackupDestinations and only return the `id`
     * const backupDestinationWithIdOnly = await prisma.backupDestination.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends BackupDestinationUpdateManyAndReturnArgs>(args: SelectSubset<T, BackupDestinationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BackupDestinationPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for BackupDestination.
   * 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__BackupDestinationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the BackupDestination model
   */
  interface BackupDestinationFieldRefs {
    readonly id: FieldRef<"BackupDestination", 'Int'>
    readonly userId: FieldRef<"BackupDestination", 'Int'>
    readonly path: FieldRef<"BackupDestination", 'String'>
    readonly isActive: FieldRef<"BackupDestination", 'Boolean'>
    readonly createdAt: FieldRef<"BackupDestination", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * BackupDestination findUnique
   */
  export type BackupDestinationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * Filter, which BackupDestination to fetch.
     */
    where: BackupDestinationWhereUniqueInput
  }

  /**
   * BackupDestination findUniqueOrThrow
   */
  export type BackupDestinationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * Filter, which BackupDestination to fetch.
     */
    where: BackupDestinationWhereUniqueInput
  }

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

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

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

  /**
   * BackupDestination create
   */
  export type BackupDestinationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * The data needed to create a BackupDestination.
     */
    data: XOR<BackupDestinationCreateInput, BackupDestinationUncheckedCreateInput>
  }

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

  /**
   * BackupDestination createManyAndReturn
   */
  export type BackupDestinationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * The data used to create many BackupDestinations.
     */
    data: BackupDestinationCreateManyInput | BackupDestinationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * BackupDestination update
   */
  export type BackupDestinationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * The data needed to update a BackupDestination.
     */
    data: XOR<BackupDestinationUpdateInput, BackupDestinationUncheckedUpdateInput>
    /**
     * Choose, which BackupDestination to update.
     */
    where: BackupDestinationWhereUniqueInput
  }

  /**
   * BackupDestination updateMany
   */
  export type BackupDestinationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update BackupDestinations.
     */
    data: XOR<BackupDestinationUpdateManyMutationInput, BackupDestinationUncheckedUpdateManyInput>
    /**
     * Filter which BackupDestinations to update
     */
    where?: BackupDestinationWhereInput
    /**
     * Limit how many BackupDestinations to update.
     */
    limit?: number
  }

  /**
   * BackupDestination updateManyAndReturn
   */
  export type BackupDestinationUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * The data used to update BackupDestinations.
     */
    data: XOR<BackupDestinationUpdateManyMutationInput, BackupDestinationUncheckedUpdateManyInput>
    /**
     * Filter which BackupDestinations to update
     */
    where?: BackupDestinationWhereInput
    /**
     * Limit how many BackupDestinations to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * BackupDestination upsert
   */
  export type BackupDestinationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * The filter to search for the BackupDestination to update in case it exists.
     */
    where: BackupDestinationWhereUniqueInput
    /**
     * In case the BackupDestination found by the `where` argument doesn't exist, create a new BackupDestination with this data.
     */
    create: XOR<BackupDestinationCreateInput, BackupDestinationUncheckedCreateInput>
    /**
     * In case the BackupDestination was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BackupDestinationUpdateInput, BackupDestinationUncheckedUpdateInput>
  }

  /**
   * BackupDestination delete
   */
  export type BackupDestinationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BackupDestination
     */
    select?: BackupDestinationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the BackupDestination
     */
    omit?: BackupDestinationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BackupDestinationInclude<ExtArgs> | null
    /**
     * Filter which BackupDestination to delete.
     */
    where: BackupDestinationWhereUniqueInput
  }

  /**
   * BackupDestination deleteMany
   */
  export type BackupDestinationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BackupDestinations to delete
     */
    where?: BackupDestinationWhereInput
    /**
     * Limit how many BackupDestinations to delete.
     */
    limit?: number
  }

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


  /**
   * Model Notification
   */

  export type AggregateNotification = {
    _count: NotificationCountAggregateOutputType | null
    _avg: NotificationAvgAggregateOutputType | null
    _sum: NotificationSumAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  export type NotificationAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type NotificationSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type NotificationMinAggregateOutputType = {
    id: number | null
    userId: number | null
    type: $Enums.NotificationTypes | null
    message: string | null
    createdAt: Date | null
    read: boolean | null
  }

  export type NotificationMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    type: $Enums.NotificationTypes | null
    message: string | null
    createdAt: Date | null
    read: boolean | null
  }

  export type NotificationCountAggregateOutputType = {
    id: number
    userId: number
    type: number
    message: number
    createdAt: number
    read: number
    _all: number
  }


  export type NotificationAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type NotificationSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type NotificationMinAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    message?: true
    createdAt?: true
    read?: true
  }

  export type NotificationMaxAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    message?: true
    createdAt?: true
    read?: true
  }

  export type NotificationCountAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    message?: true
    createdAt?: true
    read?: true
    _all?: true
  }

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

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




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

  export type NotificationGroupByOutputType = {
    id: number
    userId: number
    type: $Enums.NotificationTypes
    message: string
    createdAt: Date
    read: boolean
    _count: NotificationCountAggregateOutputType | null
    _avg: NotificationAvgAggregateOutputType | null
    _sum: NotificationSumAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

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


  export type NotificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    message?: boolean
    createdAt?: boolean
    read?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    message?: boolean
    createdAt?: boolean
    read?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    message?: boolean
    createdAt?: boolean
    read?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectScalar = {
    id?: boolean
    userId?: boolean
    type?: boolean
    message?: boolean
    createdAt?: boolean
    read?: boolean
  }

  export type NotificationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "type" | "message" | "createdAt" | "read", ExtArgs["result"]["notification"]>
  export type NotificationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type NotificationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type NotificationIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $NotificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Notification"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      type: $Enums.NotificationTypes
      message: string
      createdAt: Date
      read: boolean
    }, ExtArgs["result"]["notification"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

    /**
     * Create many Notifications and returns the data saved in the database.
     * @param {NotificationCreateManyAndReturnArgs} args - Arguments to create many Notifications.
     * @example
     * // Create many Notifications
     * const notification = await prisma.notification.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Notifications and only return the `id`
     * const notificationWithIdOnly = await prisma.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 NotificationCreateManyAndReturnArgs>(args?: SelectSubset<T, NotificationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

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

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

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

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

    /**
     * Update zero or more Notifications and returns the data updated in the database.
     * @param {NotificationUpdateManyAndReturnArgs} args - Arguments to update many Notifications.
     * @example
     * // Update many Notifications
     * const notification = await prisma.notification.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Notifications and only return the `id`
     * const notificationWithIdOnly = await prisma.notification.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends NotificationUpdateManyAndReturnArgs>(args: SelectSubset<T, NotificationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends NotificationAggregateArgs>(args: Subset<T, NotificationAggregateArgs>): Prisma.PrismaPromise<GetNotificationAggregateType<T>>

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

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




  /**
   * Fields of the Notification model
   */
  interface NotificationFieldRefs {
    readonly id: FieldRef<"Notification", 'Int'>
    readonly userId: FieldRef<"Notification", 'Int'>
    readonly type: FieldRef<"Notification", 'NotificationTypes'>
    readonly message: FieldRef<"Notification", 'String'>
    readonly createdAt: FieldRef<"Notification", 'DateTime'>
    readonly read: FieldRef<"Notification", 'Boolean'>
  }
    

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

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

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

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

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

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

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

  /**
   * Notification createManyAndReturn
   */
  export type NotificationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * The data used to create many Notifications.
     */
    data: NotificationCreateManyInput | NotificationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationIncludeCreateManyAndReturn<ExtArgs> | null
  }

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

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

  /**
   * Notification updateManyAndReturn
   */
  export type NotificationUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * The data used to update Notifications.
     */
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyInput>
    /**
     * Filter which Notifications to update
     */
    where?: NotificationWhereInput
    /**
     * Limit how many Notifications to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationIncludeUpdateManyAndReturn<ExtArgs> | null
  }

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

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

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

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


  /**
   * Model CronJobLog
   */

  export type AggregateCronJobLog = {
    _count: CronJobLogCountAggregateOutputType | null
    _avg: CronJobLogAvgAggregateOutputType | null
    _sum: CronJobLogSumAggregateOutputType | null
    _min: CronJobLogMinAggregateOutputType | null
    _max: CronJobLogMaxAggregateOutputType | null
  }

  export type CronJobLogAvgAggregateOutputType = {
    id: number | null
    durationMs: number | null
  }

  export type CronJobLogSumAggregateOutputType = {
    id: number | null
    durationMs: number | null
  }

  export type CronJobLogMinAggregateOutputType = {
    id: number | null
    jobName: string | null
    status: string | null
    startedAt: Date | null
    completedAt: Date | null
    durationMs: number | null
    errorMessage: string | null
  }

  export type CronJobLogMaxAggregateOutputType = {
    id: number | null
    jobName: string | null
    status: string | null
    startedAt: Date | null
    completedAt: Date | null
    durationMs: number | null
    errorMessage: string | null
  }

  export type CronJobLogCountAggregateOutputType = {
    id: number
    jobName: number
    status: number
    startedAt: number
    completedAt: number
    durationMs: number
    errorMessage: number
    _all: number
  }


  export type CronJobLogAvgAggregateInputType = {
    id?: true
    durationMs?: true
  }

  export type CronJobLogSumAggregateInputType = {
    id?: true
    durationMs?: true
  }

  export type CronJobLogMinAggregateInputType = {
    id?: true
    jobName?: true
    status?: true
    startedAt?: true
    completedAt?: true
    durationMs?: true
    errorMessage?: true
  }

  export type CronJobLogMaxAggregateInputType = {
    id?: true
    jobName?: true
    status?: true
    startedAt?: true
    completedAt?: true
    durationMs?: true
    errorMessage?: true
  }

  export type CronJobLogCountAggregateInputType = {
    id?: true
    jobName?: true
    status?: true
    startedAt?: true
    completedAt?: true
    durationMs?: true
    errorMessage?: true
    _all?: true
  }

  export type CronJobLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CronJobLog to aggregate.
     */
    where?: CronJobLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CronJobLogs to fetch.
     */
    orderBy?: CronJobLogOrderByWithRelationInput | CronJobLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CronJobLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CronJobLogs 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` CronJobLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CronJobLogs
    **/
    _count?: true | CronJobLogCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CronJobLogAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CronJobLogSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CronJobLogMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CronJobLogMaxAggregateInputType
  }

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




  export type CronJobLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CronJobLogWhereInput
    orderBy?: CronJobLogOrderByWithAggregationInput | CronJobLogOrderByWithAggregationInput[]
    by: CronJobLogScalarFieldEnum[] | CronJobLogScalarFieldEnum
    having?: CronJobLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CronJobLogCountAggregateInputType | true
    _avg?: CronJobLogAvgAggregateInputType
    _sum?: CronJobLogSumAggregateInputType
    _min?: CronJobLogMinAggregateInputType
    _max?: CronJobLogMaxAggregateInputType
  }

  export type CronJobLogGroupByOutputType = {
    id: number
    jobName: string
    status: string
    startedAt: Date
    completedAt: Date | null
    durationMs: number | null
    errorMessage: string | null
    _count: CronJobLogCountAggregateOutputType | null
    _avg: CronJobLogAvgAggregateOutputType | null
    _sum: CronJobLogSumAggregateOutputType | null
    _min: CronJobLogMinAggregateOutputType | null
    _max: CronJobLogMaxAggregateOutputType | null
  }

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


  export type CronJobLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobName?: boolean
    status?: boolean
    startedAt?: boolean
    completedAt?: boolean
    durationMs?: boolean
    errorMessage?: boolean
  }, ExtArgs["result"]["cronJobLog"]>

  export type CronJobLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobName?: boolean
    status?: boolean
    startedAt?: boolean
    completedAt?: boolean
    durationMs?: boolean
    errorMessage?: boolean
  }, ExtArgs["result"]["cronJobLog"]>

  export type CronJobLogSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobName?: boolean
    status?: boolean
    startedAt?: boolean
    completedAt?: boolean
    durationMs?: boolean
    errorMessage?: boolean
  }, ExtArgs["result"]["cronJobLog"]>

  export type CronJobLogSelectScalar = {
    id?: boolean
    jobName?: boolean
    status?: boolean
    startedAt?: boolean
    completedAt?: boolean
    durationMs?: boolean
    errorMessage?: boolean
  }

  export type CronJobLogOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "jobName" | "status" | "startedAt" | "completedAt" | "durationMs" | "errorMessage", ExtArgs["result"]["cronJobLog"]>

  export type $CronJobLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CronJobLog"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      jobName: string
      status: string
      startedAt: Date
      completedAt: Date | null
      durationMs: number | null
      errorMessage: string | null
    }, ExtArgs["result"]["cronJobLog"]>
    composites: {}
  }

  type CronJobLogGetPayload<S extends boolean | null | undefined | CronJobLogDefaultArgs> = $Result.GetResult<Prisma.$CronJobLogPayload, S>

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

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

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

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

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

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

    /**
     * Create a CronJobLog.
     * @param {CronJobLogCreateArgs} args - Arguments to create a CronJobLog.
     * @example
     * // Create one CronJobLog
     * const CronJobLog = await prisma.cronJobLog.create({
     *   data: {
     *     // ... data to create a CronJobLog
     *   }
     * })
     * 
     */
    create<T extends CronJobLogCreateArgs>(args: SelectSubset<T, CronJobLogCreateArgs<ExtArgs>>): Prisma__CronJobLogClient<$Result.GetResult<Prisma.$CronJobLogPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CronJobLogs and returns the data saved in the database.
     * @param {CronJobLogCreateManyAndReturnArgs} args - Arguments to create many CronJobLogs.
     * @example
     * // Create many CronJobLogs
     * const cronJobLog = await prisma.cronJobLog.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CronJobLogs and only return the `id`
     * const cronJobLogWithIdOnly = await prisma.cronJobLog.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 CronJobLogCreateManyAndReturnArgs>(args?: SelectSubset<T, CronJobLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CronJobLogPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CronJobLog.
     * @param {CronJobLogDeleteArgs} args - Arguments to delete one CronJobLog.
     * @example
     * // Delete one CronJobLog
     * const CronJobLog = await prisma.cronJobLog.delete({
     *   where: {
     *     // ... filter to delete one CronJobLog
     *   }
     * })
     * 
     */
    delete<T extends CronJobLogDeleteArgs>(args: SelectSubset<T, CronJobLogDeleteArgs<ExtArgs>>): Prisma__CronJobLogClient<$Result.GetResult<Prisma.$CronJobLogPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more CronJobLogs and returns the data updated in the database.
     * @param {CronJobLogUpdateManyAndReturnArgs} args - Arguments to update many CronJobLogs.
     * @example
     * // Update many CronJobLogs
     * const cronJobLog = await prisma.cronJobLog.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CronJobLogs and only return the `id`
     * const cronJobLogWithIdOnly = await prisma.cronJobLog.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CronJobLogUpdateManyAndReturnArgs>(args: SelectSubset<T, CronJobLogUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CronJobLogPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CronJobLog.
   * 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__CronJobLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CronJobLog model
   */
  interface CronJobLogFieldRefs {
    readonly id: FieldRef<"CronJobLog", 'Int'>
    readonly jobName: FieldRef<"CronJobLog", 'String'>
    readonly status: FieldRef<"CronJobLog", 'String'>
    readonly startedAt: FieldRef<"CronJobLog", 'DateTime'>
    readonly completedAt: FieldRef<"CronJobLog", 'DateTime'>
    readonly durationMs: FieldRef<"CronJobLog", 'Int'>
    readonly errorMessage: FieldRef<"CronJobLog", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CronJobLog findUnique
   */
  export type CronJobLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * Filter, which CronJobLog to fetch.
     */
    where: CronJobLogWhereUniqueInput
  }

  /**
   * CronJobLog findUniqueOrThrow
   */
  export type CronJobLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * Filter, which CronJobLog to fetch.
     */
    where: CronJobLogWhereUniqueInput
  }

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

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

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

  /**
   * CronJobLog create
   */
  export type CronJobLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * The data needed to create a CronJobLog.
     */
    data: XOR<CronJobLogCreateInput, CronJobLogUncheckedCreateInput>
  }

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

  /**
   * CronJobLog createManyAndReturn
   */
  export type CronJobLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * The data used to create many CronJobLogs.
     */
    data: CronJobLogCreateManyInput | CronJobLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CronJobLog update
   */
  export type CronJobLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * The data needed to update a CronJobLog.
     */
    data: XOR<CronJobLogUpdateInput, CronJobLogUncheckedUpdateInput>
    /**
     * Choose, which CronJobLog to update.
     */
    where: CronJobLogWhereUniqueInput
  }

  /**
   * CronJobLog updateMany
   */
  export type CronJobLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CronJobLogs.
     */
    data: XOR<CronJobLogUpdateManyMutationInput, CronJobLogUncheckedUpdateManyInput>
    /**
     * Filter which CronJobLogs to update
     */
    where?: CronJobLogWhereInput
    /**
     * Limit how many CronJobLogs to update.
     */
    limit?: number
  }

  /**
   * CronJobLog updateManyAndReturn
   */
  export type CronJobLogUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * The data used to update CronJobLogs.
     */
    data: XOR<CronJobLogUpdateManyMutationInput, CronJobLogUncheckedUpdateManyInput>
    /**
     * Filter which CronJobLogs to update
     */
    where?: CronJobLogWhereInput
    /**
     * Limit how many CronJobLogs to update.
     */
    limit?: number
  }

  /**
   * CronJobLog upsert
   */
  export type CronJobLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * The filter to search for the CronJobLog to update in case it exists.
     */
    where: CronJobLogWhereUniqueInput
    /**
     * In case the CronJobLog found by the `where` argument doesn't exist, create a new CronJobLog with this data.
     */
    create: XOR<CronJobLogCreateInput, CronJobLogUncheckedCreateInput>
    /**
     * In case the CronJobLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CronJobLogUpdateInput, CronJobLogUncheckedUpdateInput>
  }

  /**
   * CronJobLog delete
   */
  export type CronJobLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CronJobLog
     */
    select?: CronJobLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CronJobLog
     */
    omit?: CronJobLogOmit<ExtArgs> | null
    /**
     * Filter which CronJobLog to delete.
     */
    where: CronJobLogWhereUniqueInput
  }

  /**
   * CronJobLog deleteMany
   */
  export type CronJobLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CronJobLogs to delete
     */
    where?: CronJobLogWhereInput
    /**
     * Limit how many CronJobLogs to delete.
     */
    limit?: number
  }

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


  /**
   * Model CloudFolder
   */

  export type AggregateCloudFolder = {
    _count: CloudFolderCountAggregateOutputType | null
    _avg: CloudFolderAvgAggregateOutputType | null
    _sum: CloudFolderSumAggregateOutputType | null
    _min: CloudFolderMinAggregateOutputType | null
    _max: CloudFolderMaxAggregateOutputType | null
  }

  export type CloudFolderAvgAggregateOutputType = {
    id: number | null
    userId: number | null
    parentId: number | null
  }

  export type CloudFolderSumAggregateOutputType = {
    id: number | null
    userId: number | null
    parentId: number | null
  }

  export type CloudFolderMinAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    parentId: number | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CloudFolderMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    parentId: number | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CloudFolderCountAggregateOutputType = {
    id: number
    userId: number
    name: number
    parentId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type CloudFolderAvgAggregateInputType = {
    id?: true
    userId?: true
    parentId?: true
  }

  export type CloudFolderSumAggregateInputType = {
    id?: true
    userId?: true
    parentId?: true
  }

  export type CloudFolderMinAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    parentId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFolderMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    parentId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFolderCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    parentId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type CloudFolderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFolder to aggregate.
     */
    where?: CloudFolderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CloudFolders to fetch.
     */
    orderBy?: CloudFolderOrderByWithRelationInput | CloudFolderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CloudFolderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CloudFolders 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` CloudFolders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CloudFolders
    **/
    _count?: true | CloudFolderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CloudFolderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CloudFolderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CloudFolderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CloudFolderMaxAggregateInputType
  }

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




  export type CloudFolderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFolderWhereInput
    orderBy?: CloudFolderOrderByWithAggregationInput | CloudFolderOrderByWithAggregationInput[]
    by: CloudFolderScalarFieldEnum[] | CloudFolderScalarFieldEnum
    having?: CloudFolderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CloudFolderCountAggregateInputType | true
    _avg?: CloudFolderAvgAggregateInputType
    _sum?: CloudFolderSumAggregateInputType
    _min?: CloudFolderMinAggregateInputType
    _max?: CloudFolderMaxAggregateInputType
  }

  export type CloudFolderGroupByOutputType = {
    id: number
    userId: number
    name: string
    parentId: number | null
    createdAt: Date
    updatedAt: Date
    _count: CloudFolderCountAggregateOutputType | null
    _avg: CloudFolderAvgAggregateOutputType | null
    _sum: CloudFolderSumAggregateOutputType | null
    _min: CloudFolderMinAggregateOutputType | null
    _max: CloudFolderMaxAggregateOutputType | null
  }

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


  export type CloudFolderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    parentId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    children?: boolean | CloudFolder$childrenArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    files?: boolean | CloudFolder$filesArgs<ExtArgs>
    _count?: boolean | CloudFolderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFolder"]>

  export type CloudFolderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    parentId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFolder"]>

  export type CloudFolderSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    parentId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFolder"]>

  export type CloudFolderSelectScalar = {
    id?: boolean
    userId?: boolean
    name?: boolean
    parentId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CloudFolderOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "name" | "parentId" | "createdAt" | "updatedAt", ExtArgs["result"]["cloudFolder"]>
  export type CloudFolderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    children?: boolean | CloudFolder$childrenArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    files?: boolean | CloudFolder$filesArgs<ExtArgs>
    _count?: boolean | CloudFolderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CloudFolderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type CloudFolderIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    parent?: boolean | CloudFolder$parentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $CloudFolderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CloudFolder"
    objects: {
      parent: Prisma.$CloudFolderPayload<ExtArgs> | null
      children: Prisma.$CloudFolderPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>
      files: Prisma.$CloudFilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      name: string
      parentId: number | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["cloudFolder"]>
    composites: {}
  }

  type CloudFolderGetPayload<S extends boolean | null | undefined | CloudFolderDefaultArgs> = $Result.GetResult<Prisma.$CloudFolderPayload, S>

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

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

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

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

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

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

    /**
     * Create a CloudFolder.
     * @param {CloudFolderCreateArgs} args - Arguments to create a CloudFolder.
     * @example
     * // Create one CloudFolder
     * const CloudFolder = await prisma.cloudFolder.create({
     *   data: {
     *     // ... data to create a CloudFolder
     *   }
     * })
     * 
     */
    create<T extends CloudFolderCreateArgs>(args: SelectSubset<T, CloudFolderCreateArgs<ExtArgs>>): Prisma__CloudFolderClient<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CloudFolders and returns the data saved in the database.
     * @param {CloudFolderCreateManyAndReturnArgs} args - Arguments to create many CloudFolders.
     * @example
     * // Create many CloudFolders
     * const cloudFolder = await prisma.cloudFolder.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CloudFolders and only return the `id`
     * const cloudFolderWithIdOnly = await prisma.cloudFolder.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 CloudFolderCreateManyAndReturnArgs>(args?: SelectSubset<T, CloudFolderCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CloudFolder.
     * @param {CloudFolderDeleteArgs} args - Arguments to delete one CloudFolder.
     * @example
     * // Delete one CloudFolder
     * const CloudFolder = await prisma.cloudFolder.delete({
     *   where: {
     *     // ... filter to delete one CloudFolder
     *   }
     * })
     * 
     */
    delete<T extends CloudFolderDeleteArgs>(args: SelectSubset<T, CloudFolderDeleteArgs<ExtArgs>>): Prisma__CloudFolderClient<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more CloudFolders and returns the data updated in the database.
     * @param {CloudFolderUpdateManyAndReturnArgs} args - Arguments to update many CloudFolders.
     * @example
     * // Update many CloudFolders
     * const cloudFolder = await prisma.cloudFolder.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CloudFolders and only return the `id`
     * const cloudFolderWithIdOnly = await prisma.cloudFolder.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CloudFolderUpdateManyAndReturnArgs>(args: SelectSubset<T, CloudFolderUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CloudFolder.
   * 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__CloudFolderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    parent<T extends CloudFolder$parentArgs<ExtArgs> = {}>(args?: Subset<T, CloudFolder$parentArgs<ExtArgs>>): Prisma__CloudFolderClient<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    children<T extends CloudFolder$childrenArgs<ExtArgs> = {}>(args?: Subset<T, CloudFolder$childrenArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    files<T extends CloudFolder$filesArgs<ExtArgs> = {}>(args?: Subset<T, CloudFolder$filesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CloudFolder model
   */
  interface CloudFolderFieldRefs {
    readonly id: FieldRef<"CloudFolder", 'Int'>
    readonly userId: FieldRef<"CloudFolder", 'Int'>
    readonly name: FieldRef<"CloudFolder", 'String'>
    readonly parentId: FieldRef<"CloudFolder", 'Int'>
    readonly createdAt: FieldRef<"CloudFolder", 'DateTime'>
    readonly updatedAt: FieldRef<"CloudFolder", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CloudFolder findUnique
   */
  export type CloudFolderFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * Filter, which CloudFolder to fetch.
     */
    where: CloudFolderWhereUniqueInput
  }

  /**
   * CloudFolder findUniqueOrThrow
   */
  export type CloudFolderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * Filter, which CloudFolder to fetch.
     */
    where: CloudFolderWhereUniqueInput
  }

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

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

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

  /**
   * CloudFolder create
   */
  export type CloudFolderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * The data needed to create a CloudFolder.
     */
    data: XOR<CloudFolderCreateInput, CloudFolderUncheckedCreateInput>
  }

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

  /**
   * CloudFolder createManyAndReturn
   */
  export type CloudFolderCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * The data used to create many CloudFolders.
     */
    data: CloudFolderCreateManyInput | CloudFolderCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFolder update
   */
  export type CloudFolderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * The data needed to update a CloudFolder.
     */
    data: XOR<CloudFolderUpdateInput, CloudFolderUncheckedUpdateInput>
    /**
     * Choose, which CloudFolder to update.
     */
    where: CloudFolderWhereUniqueInput
  }

  /**
   * CloudFolder updateMany
   */
  export type CloudFolderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CloudFolders.
     */
    data: XOR<CloudFolderUpdateManyMutationInput, CloudFolderUncheckedUpdateManyInput>
    /**
     * Filter which CloudFolders to update
     */
    where?: CloudFolderWhereInput
    /**
     * Limit how many CloudFolders to update.
     */
    limit?: number
  }

  /**
   * CloudFolder updateManyAndReturn
   */
  export type CloudFolderUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * The data used to update CloudFolders.
     */
    data: XOR<CloudFolderUpdateManyMutationInput, CloudFolderUncheckedUpdateManyInput>
    /**
     * Filter which CloudFolders to update
     */
    where?: CloudFolderWhereInput
    /**
     * Limit how many CloudFolders to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFolder upsert
   */
  export type CloudFolderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * The filter to search for the CloudFolder to update in case it exists.
     */
    where: CloudFolderWhereUniqueInput
    /**
     * In case the CloudFolder found by the `where` argument doesn't exist, create a new CloudFolder with this data.
     */
    create: XOR<CloudFolderCreateInput, CloudFolderUncheckedCreateInput>
    /**
     * In case the CloudFolder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CloudFolderUpdateInput, CloudFolderUncheckedUpdateInput>
  }

  /**
   * CloudFolder delete
   */
  export type CloudFolderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    /**
     * Filter which CloudFolder to delete.
     */
    where: CloudFolderWhereUniqueInput
  }

  /**
   * CloudFolder deleteMany
   */
  export type CloudFolderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFolders to delete
     */
    where?: CloudFolderWhereInput
    /**
     * Limit how many CloudFolders to delete.
     */
    limit?: number
  }

  /**
   * CloudFolder.parent
   */
  export type CloudFolder$parentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    where?: CloudFolderWhereInput
  }

  /**
   * CloudFolder.children
   */
  export type CloudFolder$childrenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    where?: CloudFolderWhereInput
    orderBy?: CloudFolderOrderByWithRelationInput | CloudFolderOrderByWithRelationInput[]
    cursor?: CloudFolderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CloudFolderScalarFieldEnum | CloudFolderScalarFieldEnum[]
  }

  /**
   * CloudFolder.files
   */
  export type CloudFolder$filesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    where?: CloudFileWhereInput
    orderBy?: CloudFileOrderByWithRelationInput | CloudFileOrderByWithRelationInput[]
    cursor?: CloudFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CloudFileScalarFieldEnum | CloudFileScalarFieldEnum[]
  }

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


  /**
   * Model CloudFile
   */

  export type AggregateCloudFile = {
    _count: CloudFileCountAggregateOutputType | null
    _avg: CloudFileAvgAggregateOutputType | null
    _sum: CloudFileSumAggregateOutputType | null
    _min: CloudFileMinAggregateOutputType | null
    _max: CloudFileMaxAggregateOutputType | null
  }

  export type CloudFileAvgAggregateOutputType = {
    id: number | null
    userId: number | null
    fileSize: number | null
    folderId: number | null
    totalChunks: number | null
  }

  export type CloudFileSumAggregateOutputType = {
    id: number | null
    userId: number | null
    fileSize: bigint | null
    folderId: number | null
    totalChunks: number | null
  }

  export type CloudFileMinAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    mimeType: string | null
    fileSize: bigint | null
    folderId: number | null
    isComplete: boolean | null
    totalChunks: number | null
    diskPath: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CloudFileMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    mimeType: string | null
    fileSize: bigint | null
    folderId: number | null
    isComplete: boolean | null
    totalChunks: number | null
    diskPath: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CloudFileCountAggregateOutputType = {
    id: number
    userId: number
    name: number
    mimeType: number
    fileSize: number
    folderId: number
    isComplete: number
    totalChunks: number
    diskPath: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type CloudFileAvgAggregateInputType = {
    id?: true
    userId?: true
    fileSize?: true
    folderId?: true
    totalChunks?: true
  }

  export type CloudFileSumAggregateInputType = {
    id?: true
    userId?: true
    fileSize?: true
    folderId?: true
    totalChunks?: true
  }

  export type CloudFileMinAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    mimeType?: true
    fileSize?: true
    folderId?: true
    isComplete?: true
    totalChunks?: true
    diskPath?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFileMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    mimeType?: true
    fileSize?: true
    folderId?: true
    isComplete?: true
    totalChunks?: true
    diskPath?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFileCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    mimeType?: true
    fileSize?: true
    folderId?: true
    isComplete?: true
    totalChunks?: true
    diskPath?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type CloudFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFile to aggregate.
     */
    where?: CloudFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CloudFiles to fetch.
     */
    orderBy?: CloudFileOrderByWithRelationInput | CloudFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CloudFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CloudFiles 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` CloudFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CloudFiles
    **/
    _count?: true | CloudFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CloudFileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CloudFileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CloudFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CloudFileMaxAggregateInputType
  }

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




  export type CloudFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFileWhereInput
    orderBy?: CloudFileOrderByWithAggregationInput | CloudFileOrderByWithAggregationInput[]
    by: CloudFileScalarFieldEnum[] | CloudFileScalarFieldEnum
    having?: CloudFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CloudFileCountAggregateInputType | true
    _avg?: CloudFileAvgAggregateInputType
    _sum?: CloudFileSumAggregateInputType
    _min?: CloudFileMinAggregateInputType
    _max?: CloudFileMaxAggregateInputType
  }

  export type CloudFileGroupByOutputType = {
    id: number
    userId: number
    name: string
    mimeType: string | null
    fileSize: bigint
    folderId: number | null
    isComplete: boolean
    totalChunks: number | null
    diskPath: string | null
    createdAt: Date
    updatedAt: Date
    _count: CloudFileCountAggregateOutputType | null
    _avg: CloudFileAvgAggregateOutputType | null
    _sum: CloudFileSumAggregateOutputType | null
    _min: CloudFileMinAggregateOutputType | null
    _max: CloudFileMaxAggregateOutputType | null
  }

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


  export type CloudFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    mimeType?: boolean
    fileSize?: boolean
    folderId?: boolean
    isComplete?: boolean
    totalChunks?: boolean
    diskPath?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
    chunks?: boolean | CloudFile$chunksArgs<ExtArgs>
    _count?: boolean | CloudFileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFile"]>

  export type CloudFileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    mimeType?: boolean
    fileSize?: boolean
    folderId?: boolean
    isComplete?: boolean
    totalChunks?: boolean
    diskPath?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFile"]>

  export type CloudFileSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    mimeType?: boolean
    fileSize?: boolean
    folderId?: boolean
    isComplete?: boolean
    totalChunks?: boolean
    diskPath?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFile"]>

  export type CloudFileSelectScalar = {
    id?: boolean
    userId?: boolean
    name?: boolean
    mimeType?: boolean
    fileSize?: boolean
    folderId?: boolean
    isComplete?: boolean
    totalChunks?: boolean
    diskPath?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CloudFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "name" | "mimeType" | "fileSize" | "folderId" | "isComplete" | "totalChunks" | "diskPath" | "createdAt" | "updatedAt", ExtArgs["result"]["cloudFile"]>
  export type CloudFileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
    chunks?: boolean | CloudFile$chunksArgs<ExtArgs>
    _count?: boolean | CloudFileCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CloudFileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
  }
  export type CloudFileIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    folder?: boolean | CloudFile$folderArgs<ExtArgs>
  }

  export type $CloudFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CloudFile"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      folder: Prisma.$CloudFolderPayload<ExtArgs> | null
      chunks: Prisma.$CloudFileChunkPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      name: string
      mimeType: string | null
      fileSize: bigint
      folderId: number | null
      isComplete: boolean
      totalChunks: number | null
      diskPath: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["cloudFile"]>
    composites: {}
  }

  type CloudFileGetPayload<S extends boolean | null | undefined | CloudFileDefaultArgs> = $Result.GetResult<Prisma.$CloudFilePayload, S>

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

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

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

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

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

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

    /**
     * Create a CloudFile.
     * @param {CloudFileCreateArgs} args - Arguments to create a CloudFile.
     * @example
     * // Create one CloudFile
     * const CloudFile = await prisma.cloudFile.create({
     *   data: {
     *     // ... data to create a CloudFile
     *   }
     * })
     * 
     */
    create<T extends CloudFileCreateArgs>(args: SelectSubset<T, CloudFileCreateArgs<ExtArgs>>): Prisma__CloudFileClient<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CloudFiles and returns the data saved in the database.
     * @param {CloudFileCreateManyAndReturnArgs} args - Arguments to create many CloudFiles.
     * @example
     * // Create many CloudFiles
     * const cloudFile = await prisma.cloudFile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CloudFiles and only return the `id`
     * const cloudFileWithIdOnly = await prisma.cloudFile.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 CloudFileCreateManyAndReturnArgs>(args?: SelectSubset<T, CloudFileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CloudFile.
     * @param {CloudFileDeleteArgs} args - Arguments to delete one CloudFile.
     * @example
     * // Delete one CloudFile
     * const CloudFile = await prisma.cloudFile.delete({
     *   where: {
     *     // ... filter to delete one CloudFile
     *   }
     * })
     * 
     */
    delete<T extends CloudFileDeleteArgs>(args: SelectSubset<T, CloudFileDeleteArgs<ExtArgs>>): Prisma__CloudFileClient<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more CloudFiles and returns the data updated in the database.
     * @param {CloudFileUpdateManyAndReturnArgs} args - Arguments to update many CloudFiles.
     * @example
     * // Update many CloudFiles
     * const cloudFile = await prisma.cloudFile.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CloudFiles and only return the `id`
     * const cloudFileWithIdOnly = await prisma.cloudFile.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CloudFileUpdateManyAndReturnArgs>(args: SelectSubset<T, CloudFileUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CloudFile.
   * 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__CloudFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    folder<T extends CloudFile$folderArgs<ExtArgs> = {}>(args?: Subset<T, CloudFile$folderArgs<ExtArgs>>): Prisma__CloudFolderClient<$Result.GetResult<Prisma.$CloudFolderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    chunks<T extends CloudFile$chunksArgs<ExtArgs> = {}>(args?: Subset<T, CloudFile$chunksArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFileChunkPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CloudFile model
   */
  interface CloudFileFieldRefs {
    readonly id: FieldRef<"CloudFile", 'Int'>
    readonly userId: FieldRef<"CloudFile", 'Int'>
    readonly name: FieldRef<"CloudFile", 'String'>
    readonly mimeType: FieldRef<"CloudFile", 'String'>
    readonly fileSize: FieldRef<"CloudFile", 'BigInt'>
    readonly folderId: FieldRef<"CloudFile", 'Int'>
    readonly isComplete: FieldRef<"CloudFile", 'Boolean'>
    readonly totalChunks: FieldRef<"CloudFile", 'Int'>
    readonly diskPath: FieldRef<"CloudFile", 'String'>
    readonly createdAt: FieldRef<"CloudFile", 'DateTime'>
    readonly updatedAt: FieldRef<"CloudFile", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CloudFile findUnique
   */
  export type CloudFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * Filter, which CloudFile to fetch.
     */
    where: CloudFileWhereUniqueInput
  }

  /**
   * CloudFile findUniqueOrThrow
   */
  export type CloudFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * Filter, which CloudFile to fetch.
     */
    where: CloudFileWhereUniqueInput
  }

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

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

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

  /**
   * CloudFile create
   */
  export type CloudFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * The data needed to create a CloudFile.
     */
    data: XOR<CloudFileCreateInput, CloudFileUncheckedCreateInput>
  }

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

  /**
   * CloudFile createManyAndReturn
   */
  export type CloudFileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * The data used to create many CloudFiles.
     */
    data: CloudFileCreateManyInput | CloudFileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFile update
   */
  export type CloudFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * The data needed to update a CloudFile.
     */
    data: XOR<CloudFileUpdateInput, CloudFileUncheckedUpdateInput>
    /**
     * Choose, which CloudFile to update.
     */
    where: CloudFileWhereUniqueInput
  }

  /**
   * CloudFile updateMany
   */
  export type CloudFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CloudFiles.
     */
    data: XOR<CloudFileUpdateManyMutationInput, CloudFileUncheckedUpdateManyInput>
    /**
     * Filter which CloudFiles to update
     */
    where?: CloudFileWhereInput
    /**
     * Limit how many CloudFiles to update.
     */
    limit?: number
  }

  /**
   * CloudFile updateManyAndReturn
   */
  export type CloudFileUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * The data used to update CloudFiles.
     */
    data: XOR<CloudFileUpdateManyMutationInput, CloudFileUncheckedUpdateManyInput>
    /**
     * Filter which CloudFiles to update
     */
    where?: CloudFileWhereInput
    /**
     * Limit how many CloudFiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFile upsert
   */
  export type CloudFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * The filter to search for the CloudFile to update in case it exists.
     */
    where: CloudFileWhereUniqueInput
    /**
     * In case the CloudFile found by the `where` argument doesn't exist, create a new CloudFile with this data.
     */
    create: XOR<CloudFileCreateInput, CloudFileUncheckedCreateInput>
    /**
     * In case the CloudFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CloudFileUpdateInput, CloudFileUncheckedUpdateInput>
  }

  /**
   * CloudFile delete
   */
  export type CloudFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFile
     */
    select?: CloudFileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFile
     */
    omit?: CloudFileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileInclude<ExtArgs> | null
    /**
     * Filter which CloudFile to delete.
     */
    where: CloudFileWhereUniqueInput
  }

  /**
   * CloudFile deleteMany
   */
  export type CloudFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFiles to delete
     */
    where?: CloudFileWhereInput
    /**
     * Limit how many CloudFiles to delete.
     */
    limit?: number
  }

  /**
   * CloudFile.folder
   */
  export type CloudFile$folderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFolder
     */
    select?: CloudFolderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFolder
     */
    omit?: CloudFolderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFolderInclude<ExtArgs> | null
    where?: CloudFolderWhereInput
  }

  /**
   * CloudFile.chunks
   */
  export type CloudFile$chunksArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    where?: CloudFileChunkWhereInput
    orderBy?: CloudFileChunkOrderByWithRelationInput | CloudFileChunkOrderByWithRelationInput[]
    cursor?: CloudFileChunkWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CloudFileChunkScalarFieldEnum | CloudFileChunkScalarFieldEnum[]
  }

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


  /**
   * Model CloudFileChunk
   */

  export type AggregateCloudFileChunk = {
    _count: CloudFileChunkCountAggregateOutputType | null
    _avg: CloudFileChunkAvgAggregateOutputType | null
    _sum: CloudFileChunkSumAggregateOutputType | null
    _min: CloudFileChunkMinAggregateOutputType | null
    _max: CloudFileChunkMaxAggregateOutputType | null
  }

  export type CloudFileChunkAvgAggregateOutputType = {
    id: number | null
    fileId: number | null
    seq: number | null
  }

  export type CloudFileChunkSumAggregateOutputType = {
    id: number | null
    fileId: number | null
    seq: number | null
  }

  export type CloudFileChunkMinAggregateOutputType = {
    id: number | null
    fileId: number | null
    seq: number | null
    data: Bytes | null
    createdAt: Date | null
  }

  export type CloudFileChunkMaxAggregateOutputType = {
    id: number | null
    fileId: number | null
    seq: number | null
    data: Bytes | null
    createdAt: Date | null
  }

  export type CloudFileChunkCountAggregateOutputType = {
    id: number
    fileId: number
    seq: number
    data: number
    createdAt: number
    _all: number
  }


  export type CloudFileChunkAvgAggregateInputType = {
    id?: true
    fileId?: true
    seq?: true
  }

  export type CloudFileChunkSumAggregateInputType = {
    id?: true
    fileId?: true
    seq?: true
  }

  export type CloudFileChunkMinAggregateInputType = {
    id?: true
    fileId?: true
    seq?: true
    data?: true
    createdAt?: true
  }

  export type CloudFileChunkMaxAggregateInputType = {
    id?: true
    fileId?: true
    seq?: true
    data?: true
    createdAt?: true
  }

  export type CloudFileChunkCountAggregateInputType = {
    id?: true
    fileId?: true
    seq?: true
    data?: true
    createdAt?: true
    _all?: true
  }

  export type CloudFileChunkAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFileChunk to aggregate.
     */
    where?: CloudFileChunkWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CloudFileChunks to fetch.
     */
    orderBy?: CloudFileChunkOrderByWithRelationInput | CloudFileChunkOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CloudFileChunkWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CloudFileChunks 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` CloudFileChunks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CloudFileChunks
    **/
    _count?: true | CloudFileChunkCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CloudFileChunkAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CloudFileChunkSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CloudFileChunkMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CloudFileChunkMaxAggregateInputType
  }

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




  export type CloudFileChunkGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CloudFileChunkWhereInput
    orderBy?: CloudFileChunkOrderByWithAggregationInput | CloudFileChunkOrderByWithAggregationInput[]
    by: CloudFileChunkScalarFieldEnum[] | CloudFileChunkScalarFieldEnum
    having?: CloudFileChunkScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CloudFileChunkCountAggregateInputType | true
    _avg?: CloudFileChunkAvgAggregateInputType
    _sum?: CloudFileChunkSumAggregateInputType
    _min?: CloudFileChunkMinAggregateInputType
    _max?: CloudFileChunkMaxAggregateInputType
  }

  export type CloudFileChunkGroupByOutputType = {
    id: number
    fileId: number
    seq: number
    data: Bytes
    createdAt: Date
    _count: CloudFileChunkCountAggregateOutputType | null
    _avg: CloudFileChunkAvgAggregateOutputType | null
    _sum: CloudFileChunkSumAggregateOutputType | null
    _min: CloudFileChunkMinAggregateOutputType | null
    _max: CloudFileChunkMaxAggregateOutputType | null
  }

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


  export type CloudFileChunkSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fileId?: boolean
    seq?: boolean
    data?: boolean
    createdAt?: boolean
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFileChunk"]>

  export type CloudFileChunkSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fileId?: boolean
    seq?: boolean
    data?: boolean
    createdAt?: boolean
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFileChunk"]>

  export type CloudFileChunkSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fileId?: boolean
    seq?: boolean
    data?: boolean
    createdAt?: boolean
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cloudFileChunk"]>

  export type CloudFileChunkSelectScalar = {
    id?: boolean
    fileId?: boolean
    seq?: boolean
    data?: boolean
    createdAt?: boolean
  }

  export type CloudFileChunkOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "fileId" | "seq" | "data" | "createdAt", ExtArgs["result"]["cloudFileChunk"]>
  export type CloudFileChunkInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }
  export type CloudFileChunkIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }
  export type CloudFileChunkIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    file?: boolean | CloudFileDefaultArgs<ExtArgs>
  }

  export type $CloudFileChunkPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CloudFileChunk"
    objects: {
      file: Prisma.$CloudFilePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      fileId: number
      seq: number
      data: Prisma.Bytes
      createdAt: Date
    }, ExtArgs["result"]["cloudFileChunk"]>
    composites: {}
  }

  type CloudFileChunkGetPayload<S extends boolean | null | undefined | CloudFileChunkDefaultArgs> = $Result.GetResult<Prisma.$CloudFileChunkPayload, S>

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

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

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

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

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

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

    /**
     * Create a CloudFileChunk.
     * @param {CloudFileChunkCreateArgs} args - Arguments to create a CloudFileChunk.
     * @example
     * // Create one CloudFileChunk
     * const CloudFileChunk = await prisma.cloudFileChunk.create({
     *   data: {
     *     // ... data to create a CloudFileChunk
     *   }
     * })
     * 
     */
    create<T extends CloudFileChunkCreateArgs>(args: SelectSubset<T, CloudFileChunkCreateArgs<ExtArgs>>): Prisma__CloudFileChunkClient<$Result.GetResult<Prisma.$CloudFileChunkPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CloudFileChunks and returns the data saved in the database.
     * @param {CloudFileChunkCreateManyAndReturnArgs} args - Arguments to create many CloudFileChunks.
     * @example
     * // Create many CloudFileChunks
     * const cloudFileChunk = await prisma.cloudFileChunk.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CloudFileChunks and only return the `id`
     * const cloudFileChunkWithIdOnly = await prisma.cloudFileChunk.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 CloudFileChunkCreateManyAndReturnArgs>(args?: SelectSubset<T, CloudFileChunkCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFileChunkPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CloudFileChunk.
     * @param {CloudFileChunkDeleteArgs} args - Arguments to delete one CloudFileChunk.
     * @example
     * // Delete one CloudFileChunk
     * const CloudFileChunk = await prisma.cloudFileChunk.delete({
     *   where: {
     *     // ... filter to delete one CloudFileChunk
     *   }
     * })
     * 
     */
    delete<T extends CloudFileChunkDeleteArgs>(args: SelectSubset<T, CloudFileChunkDeleteArgs<ExtArgs>>): Prisma__CloudFileChunkClient<$Result.GetResult<Prisma.$CloudFileChunkPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more CloudFileChunks and returns the data updated in the database.
     * @param {CloudFileChunkUpdateManyAndReturnArgs} args - Arguments to update many CloudFileChunks.
     * @example
     * // Update many CloudFileChunks
     * const cloudFileChunk = await prisma.cloudFileChunk.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CloudFileChunks and only return the `id`
     * const cloudFileChunkWithIdOnly = await prisma.cloudFileChunk.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CloudFileChunkUpdateManyAndReturnArgs>(args: SelectSubset<T, CloudFileChunkUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CloudFileChunkPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CloudFileChunk.
   * 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__CloudFileChunkClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    file<T extends CloudFileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CloudFileDefaultArgs<ExtArgs>>): Prisma__CloudFileClient<$Result.GetResult<Prisma.$CloudFilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CloudFileChunk model
   */
  interface CloudFileChunkFieldRefs {
    readonly id: FieldRef<"CloudFileChunk", 'Int'>
    readonly fileId: FieldRef<"CloudFileChunk", 'Int'>
    readonly seq: FieldRef<"CloudFileChunk", 'Int'>
    readonly data: FieldRef<"CloudFileChunk", 'Bytes'>
    readonly createdAt: FieldRef<"CloudFileChunk", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CloudFileChunk findUnique
   */
  export type CloudFileChunkFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * Filter, which CloudFileChunk to fetch.
     */
    where: CloudFileChunkWhereUniqueInput
  }

  /**
   * CloudFileChunk findUniqueOrThrow
   */
  export type CloudFileChunkFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * Filter, which CloudFileChunk to fetch.
     */
    where: CloudFileChunkWhereUniqueInput
  }

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

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

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

  /**
   * CloudFileChunk create
   */
  export type CloudFileChunkCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * The data needed to create a CloudFileChunk.
     */
    data: XOR<CloudFileChunkCreateInput, CloudFileChunkUncheckedCreateInput>
  }

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

  /**
   * CloudFileChunk createManyAndReturn
   */
  export type CloudFileChunkCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * The data used to create many CloudFileChunks.
     */
    data: CloudFileChunkCreateManyInput | CloudFileChunkCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFileChunk update
   */
  export type CloudFileChunkUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * The data needed to update a CloudFileChunk.
     */
    data: XOR<CloudFileChunkUpdateInput, CloudFileChunkUncheckedUpdateInput>
    /**
     * Choose, which CloudFileChunk to update.
     */
    where: CloudFileChunkWhereUniqueInput
  }

  /**
   * CloudFileChunk updateMany
   */
  export type CloudFileChunkUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CloudFileChunks.
     */
    data: XOR<CloudFileChunkUpdateManyMutationInput, CloudFileChunkUncheckedUpdateManyInput>
    /**
     * Filter which CloudFileChunks to update
     */
    where?: CloudFileChunkWhereInput
    /**
     * Limit how many CloudFileChunks to update.
     */
    limit?: number
  }

  /**
   * CloudFileChunk updateManyAndReturn
   */
  export type CloudFileChunkUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * The data used to update CloudFileChunks.
     */
    data: XOR<CloudFileChunkUpdateManyMutationInput, CloudFileChunkUncheckedUpdateManyInput>
    /**
     * Filter which CloudFileChunks to update
     */
    where?: CloudFileChunkWhereInput
    /**
     * Limit how many CloudFileChunks to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * CloudFileChunk upsert
   */
  export type CloudFileChunkUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * The filter to search for the CloudFileChunk to update in case it exists.
     */
    where: CloudFileChunkWhereUniqueInput
    /**
     * In case the CloudFileChunk found by the `where` argument doesn't exist, create a new CloudFileChunk with this data.
     */
    create: XOR<CloudFileChunkCreateInput, CloudFileChunkUncheckedCreateInput>
    /**
     * In case the CloudFileChunk was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CloudFileChunkUpdateInput, CloudFileChunkUncheckedUpdateInput>
  }

  /**
   * CloudFileChunk delete
   */
  export type CloudFileChunkDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CloudFileChunk
     */
    select?: CloudFileChunkSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CloudFileChunk
     */
    omit?: CloudFileChunkOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CloudFileChunkInclude<ExtArgs> | null
    /**
     * Filter which CloudFileChunk to delete.
     */
    where: CloudFileChunkWhereUniqueInput
  }

  /**
   * CloudFileChunk deleteMany
   */
  export type CloudFileChunkDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CloudFileChunks to delete
     */
    where?: CloudFileChunkWhereInput
    /**
     * Limit how many CloudFileChunks to delete.
     */
    limit?: number
  }

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


  /**
   * Model Communication
   */

  export type AggregateCommunication = {
    _count: CommunicationCountAggregateOutputType | null
    _avg: CommunicationAvgAggregateOutputType | null
    _sum: CommunicationSumAggregateOutputType | null
    _min: CommunicationMinAggregateOutputType | null
    _max: CommunicationMaxAggregateOutputType | null
  }

  export type CommunicationAvgAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    callDuration: number | null
  }

  export type CommunicationSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    callDuration: number | null
  }

  export type CommunicationMinAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    channel: $Enums.CommunicationChannel | null
    direction: $Enums.CommunicationDirection | null
    status: $Enums.CommunicationStatus | null
    body: string | null
    callDuration: number | null
    twilioSid: string | null
    createdAt: Date | null
  }

  export type CommunicationMaxAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    channel: $Enums.CommunicationChannel | null
    direction: $Enums.CommunicationDirection | null
    status: $Enums.CommunicationStatus | null
    body: string | null
    callDuration: number | null
    twilioSid: string | null
    createdAt: Date | null
  }

  export type CommunicationCountAggregateOutputType = {
    id: number
    patientId: number
    userId: number
    channel: number
    direction: number
    status: number
    body: number
    callDuration: number
    twilioSid: number
    createdAt: number
    _all: number
  }


  export type CommunicationAvgAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    callDuration?: true
  }

  export type CommunicationSumAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    callDuration?: true
  }

  export type CommunicationMinAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    channel?: true
    direction?: true
    status?: true
    body?: true
    callDuration?: true
    twilioSid?: true
    createdAt?: true
  }

  export type CommunicationMaxAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    channel?: true
    direction?: true
    status?: true
    body?: true
    callDuration?: true
    twilioSid?: true
    createdAt?: true
  }

  export type CommunicationCountAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    channel?: true
    direction?: true
    status?: true
    body?: true
    callDuration?: true
    twilioSid?: true
    createdAt?: true
    _all?: true
  }

  export type CommunicationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Communication to aggregate.
     */
    where?: CommunicationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Communications to fetch.
     */
    orderBy?: CommunicationOrderByWithRelationInput | CommunicationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CommunicationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Communications 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` Communications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Communications
    **/
    _count?: true | CommunicationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CommunicationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CommunicationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CommunicationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CommunicationMaxAggregateInputType
  }

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




  export type CommunicationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommunicationWhereInput
    orderBy?: CommunicationOrderByWithAggregationInput | CommunicationOrderByWithAggregationInput[]
    by: CommunicationScalarFieldEnum[] | CommunicationScalarFieldEnum
    having?: CommunicationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommunicationCountAggregateInputType | true
    _avg?: CommunicationAvgAggregateInputType
    _sum?: CommunicationSumAggregateInputType
    _min?: CommunicationMinAggregateInputType
    _max?: CommunicationMaxAggregateInputType
  }

  export type CommunicationGroupByOutputType = {
    id: number
    patientId: number
    userId: number | null
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body: string | null
    callDuration: number | null
    twilioSid: string | null
    createdAt: Date
    _count: CommunicationCountAggregateOutputType | null
    _avg: CommunicationAvgAggregateOutputType | null
    _sum: CommunicationSumAggregateOutputType | null
    _min: CommunicationMinAggregateOutputType | null
    _max: CommunicationMaxAggregateOutputType | null
  }

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


  export type CommunicationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    channel?: boolean
    direction?: boolean
    status?: boolean
    body?: boolean
    callDuration?: boolean
    twilioSid?: boolean
    createdAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }, ExtArgs["result"]["communication"]>

  export type CommunicationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    channel?: boolean
    direction?: boolean
    status?: boolean
    body?: boolean
    callDuration?: boolean
    twilioSid?: boolean
    createdAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }, ExtArgs["result"]["communication"]>

  export type CommunicationSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    channel?: boolean
    direction?: boolean
    status?: boolean
    body?: boolean
    callDuration?: boolean
    twilioSid?: boolean
    createdAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }, ExtArgs["result"]["communication"]>

  export type CommunicationSelectScalar = {
    id?: boolean
    patientId?: boolean
    userId?: boolean
    channel?: boolean
    direction?: boolean
    status?: boolean
    body?: boolean
    callDuration?: boolean
    twilioSid?: boolean
    createdAt?: boolean
  }

  export type CommunicationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "patientId" | "userId" | "channel" | "direction" | "status" | "body" | "callDuration" | "twilioSid" | "createdAt", ExtArgs["result"]["communication"]>
  export type CommunicationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }
  export type CommunicationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }
  export type CommunicationIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | Communication$userArgs<ExtArgs>
  }

  export type $CommunicationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Communication"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      userId: number | null
      channel: $Enums.CommunicationChannel
      direction: $Enums.CommunicationDirection
      status: $Enums.CommunicationStatus
      body: string | null
      callDuration: number | null
      twilioSid: string | null
      createdAt: Date
    }, ExtArgs["result"]["communication"]>
    composites: {}
  }

  type CommunicationGetPayload<S extends boolean | null | undefined | CommunicationDefaultArgs> = $Result.GetResult<Prisma.$CommunicationPayload, S>

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

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

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

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

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

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

    /**
     * Create a Communication.
     * @param {CommunicationCreateArgs} args - Arguments to create a Communication.
     * @example
     * // Create one Communication
     * const Communication = await prisma.communication.create({
     *   data: {
     *     // ... data to create a Communication
     *   }
     * })
     * 
     */
    create<T extends CommunicationCreateArgs>(args: SelectSubset<T, CommunicationCreateArgs<ExtArgs>>): Prisma__CommunicationClient<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Communications and returns the data saved in the database.
     * @param {CommunicationCreateManyAndReturnArgs} args - Arguments to create many Communications.
     * @example
     * // Create many Communications
     * const communication = await prisma.communication.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Communications and only return the `id`
     * const communicationWithIdOnly = await prisma.communication.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 CommunicationCreateManyAndReturnArgs>(args?: SelectSubset<T, CommunicationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Communication.
     * @param {CommunicationDeleteArgs} args - Arguments to delete one Communication.
     * @example
     * // Delete one Communication
     * const Communication = await prisma.communication.delete({
     *   where: {
     *     // ... filter to delete one Communication
     *   }
     * })
     * 
     */
    delete<T extends CommunicationDeleteArgs>(args: SelectSubset<T, CommunicationDeleteArgs<ExtArgs>>): Prisma__CommunicationClient<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more Communications and returns the data updated in the database.
     * @param {CommunicationUpdateManyAndReturnArgs} args - Arguments to update many Communications.
     * @example
     * // Update many Communications
     * const communication = await prisma.communication.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Communications and only return the `id`
     * const communicationWithIdOnly = await prisma.communication.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CommunicationUpdateManyAndReturnArgs>(args: SelectSubset<T, CommunicationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommunicationPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Communication.
   * 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__CommunicationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends Communication$userArgs<ExtArgs> = {}>(args?: Subset<T, Communication$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Communication model
   */
  interface CommunicationFieldRefs {
    readonly id: FieldRef<"Communication", 'Int'>
    readonly patientId: FieldRef<"Communication", 'Int'>
    readonly userId: FieldRef<"Communication", 'Int'>
    readonly channel: FieldRef<"Communication", 'CommunicationChannel'>
    readonly direction: FieldRef<"Communication", 'CommunicationDirection'>
    readonly status: FieldRef<"Communication", 'CommunicationStatus'>
    readonly body: FieldRef<"Communication", 'String'>
    readonly callDuration: FieldRef<"Communication", 'Int'>
    readonly twilioSid: FieldRef<"Communication", 'String'>
    readonly createdAt: FieldRef<"Communication", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Communication findUnique
   */
  export type CommunicationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * Filter, which Communication to fetch.
     */
    where: CommunicationWhereUniqueInput
  }

  /**
   * Communication findUniqueOrThrow
   */
  export type CommunicationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * Filter, which Communication to fetch.
     */
    where: CommunicationWhereUniqueInput
  }

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

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

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

  /**
   * Communication create
   */
  export type CommunicationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * The data needed to create a Communication.
     */
    data: XOR<CommunicationCreateInput, CommunicationUncheckedCreateInput>
  }

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

  /**
   * Communication createManyAndReturn
   */
  export type CommunicationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * The data used to create many Communications.
     */
    data: CommunicationCreateManyInput | CommunicationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Communication update
   */
  export type CommunicationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * The data needed to update a Communication.
     */
    data: XOR<CommunicationUpdateInput, CommunicationUncheckedUpdateInput>
    /**
     * Choose, which Communication to update.
     */
    where: CommunicationWhereUniqueInput
  }

  /**
   * Communication updateMany
   */
  export type CommunicationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Communications.
     */
    data: XOR<CommunicationUpdateManyMutationInput, CommunicationUncheckedUpdateManyInput>
    /**
     * Filter which Communications to update
     */
    where?: CommunicationWhereInput
    /**
     * Limit how many Communications to update.
     */
    limit?: number
  }

  /**
   * Communication updateManyAndReturn
   */
  export type CommunicationUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * The data used to update Communications.
     */
    data: XOR<CommunicationUpdateManyMutationInput, CommunicationUncheckedUpdateManyInput>
    /**
     * Filter which Communications to update
     */
    where?: CommunicationWhereInput
    /**
     * Limit how many Communications to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Communication upsert
   */
  export type CommunicationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * The filter to search for the Communication to update in case it exists.
     */
    where: CommunicationWhereUniqueInput
    /**
     * In case the Communication found by the `where` argument doesn't exist, create a new Communication with this data.
     */
    create: XOR<CommunicationCreateInput, CommunicationUncheckedCreateInput>
    /**
     * In case the Communication was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommunicationUpdateInput, CommunicationUncheckedUpdateInput>
  }

  /**
   * Communication delete
   */
  export type CommunicationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Communication
     */
    select?: CommunicationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Communication
     */
    omit?: CommunicationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommunicationInclude<ExtArgs> | null
    /**
     * Filter which Communication to delete.
     */
    where: CommunicationWhereUniqueInput
  }

  /**
   * Communication deleteMany
   */
  export type CommunicationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Communications to delete
     */
    where?: CommunicationWhereInput
    /**
     * Limit how many Communications to delete.
     */
    limit?: number
  }

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

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


  /**
   * Model PatientDocument
   */

  export type AggregatePatientDocument = {
    _count: PatientDocumentCountAggregateOutputType | null
    _avg: PatientDocumentAvgAggregateOutputType | null
    _sum: PatientDocumentSumAggregateOutputType | null
    _min: PatientDocumentMinAggregateOutputType | null
    _max: PatientDocumentMaxAggregateOutputType | null
  }

  export type PatientDocumentAvgAggregateOutputType = {
    id: number | null
    patientId: number | null
    fileSize: number | null
  }

  export type PatientDocumentSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    fileSize: bigint | null
  }

  export type PatientDocumentMinAggregateOutputType = {
    id: number | null
    patientId: number | null
    filename: string | null
    originalName: string | null
    mimeType: string | null
    fileSize: bigint | null
    filePath: string | null
    uploadedAt: Date | null
    updatedAt: Date | null
  }

  export type PatientDocumentMaxAggregateOutputType = {
    id: number | null
    patientId: number | null
    filename: string | null
    originalName: string | null
    mimeType: string | null
    fileSize: bigint | null
    filePath: string | null
    uploadedAt: Date | null
    updatedAt: Date | null
  }

  export type PatientDocumentCountAggregateOutputType = {
    id: number
    patientId: number
    filename: number
    originalName: number
    mimeType: number
    fileSize: number
    filePath: number
    uploadedAt: number
    updatedAt: number
    _all: number
  }


  export type PatientDocumentAvgAggregateInputType = {
    id?: true
    patientId?: true
    fileSize?: true
  }

  export type PatientDocumentSumAggregateInputType = {
    id?: true
    patientId?: true
    fileSize?: true
  }

  export type PatientDocumentMinAggregateInputType = {
    id?: true
    patientId?: true
    filename?: true
    originalName?: true
    mimeType?: true
    fileSize?: true
    filePath?: true
    uploadedAt?: true
    updatedAt?: true
  }

  export type PatientDocumentMaxAggregateInputType = {
    id?: true
    patientId?: true
    filename?: true
    originalName?: true
    mimeType?: true
    fileSize?: true
    filePath?: true
    uploadedAt?: true
    updatedAt?: true
  }

  export type PatientDocumentCountAggregateInputType = {
    id?: true
    patientId?: true
    filename?: true
    originalName?: true
    mimeType?: true
    fileSize?: true
    filePath?: true
    uploadedAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PatientDocumentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PatientDocument to aggregate.
     */
    where?: PatientDocumentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PatientDocuments to fetch.
     */
    orderBy?: PatientDocumentOrderByWithRelationInput | PatientDocumentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PatientDocumentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PatientDocuments 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` PatientDocuments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PatientDocuments
    **/
    _count?: true | PatientDocumentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PatientDocumentAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PatientDocumentSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PatientDocumentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PatientDocumentMaxAggregateInputType
  }

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




  export type PatientDocumentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PatientDocumentWhereInput
    orderBy?: PatientDocumentOrderByWithAggregationInput | PatientDocumentOrderByWithAggregationInput[]
    by: PatientDocumentScalarFieldEnum[] | PatientDocumentScalarFieldEnum
    having?: PatientDocumentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PatientDocumentCountAggregateInputType | true
    _avg?: PatientDocumentAvgAggregateInputType
    _sum?: PatientDocumentSumAggregateInputType
    _min?: PatientDocumentMinAggregateInputType
    _max?: PatientDocumentMaxAggregateInputType
  }

  export type PatientDocumentGroupByOutputType = {
    id: number
    patientId: number
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint
    filePath: string
    uploadedAt: Date
    updatedAt: Date
    _count: PatientDocumentCountAggregateOutputType | null
    _avg: PatientDocumentAvgAggregateOutputType | null
    _sum: PatientDocumentSumAggregateOutputType | null
    _min: PatientDocumentMinAggregateOutputType | null
    _max: PatientDocumentMaxAggregateOutputType | null
  }

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


  export type PatientDocumentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    filename?: boolean
    originalName?: boolean
    mimeType?: boolean
    fileSize?: boolean
    filePath?: boolean
    uploadedAt?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientDocument"]>

  export type PatientDocumentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    filename?: boolean
    originalName?: boolean
    mimeType?: boolean
    fileSize?: boolean
    filePath?: boolean
    uploadedAt?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientDocument"]>

  export type PatientDocumentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    filename?: boolean
    originalName?: boolean
    mimeType?: boolean
    fileSize?: boolean
    filePath?: boolean
    uploadedAt?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientDocument"]>

  export type PatientDocumentSelectScalar = {
    id?: boolean
    patientId?: boolean
    filename?: boolean
    originalName?: boolean
    mimeType?: boolean
    fileSize?: boolean
    filePath?: boolean
    uploadedAt?: boolean
    updatedAt?: boolean
  }

  export type PatientDocumentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "patientId" | "filename" | "originalName" | "mimeType" | "fileSize" | "filePath" | "uploadedAt" | "updatedAt", ExtArgs["result"]["patientDocument"]>
  export type PatientDocumentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }
  export type PatientDocumentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }
  export type PatientDocumentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }

  export type $PatientDocumentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PatientDocument"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      filename: string
      originalName: string
      mimeType: string
      fileSize: bigint
      filePath: string
      uploadedAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["patientDocument"]>
    composites: {}
  }

  type PatientDocumentGetPayload<S extends boolean | null | undefined | PatientDocumentDefaultArgs> = $Result.GetResult<Prisma.$PatientDocumentPayload, S>

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

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

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

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

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

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

    /**
     * Create a PatientDocument.
     * @param {PatientDocumentCreateArgs} args - Arguments to create a PatientDocument.
     * @example
     * // Create one PatientDocument
     * const PatientDocument = await prisma.patientDocument.create({
     *   data: {
     *     // ... data to create a PatientDocument
     *   }
     * })
     * 
     */
    create<T extends PatientDocumentCreateArgs>(args: SelectSubset<T, PatientDocumentCreateArgs<ExtArgs>>): Prisma__PatientDocumentClient<$Result.GetResult<Prisma.$PatientDocumentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many PatientDocuments and returns the data saved in the database.
     * @param {PatientDocumentCreateManyAndReturnArgs} args - Arguments to create many PatientDocuments.
     * @example
     * // Create many PatientDocuments
     * const patientDocument = await prisma.patientDocument.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many PatientDocuments and only return the `id`
     * const patientDocumentWithIdOnly = await prisma.patientDocument.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 PatientDocumentCreateManyAndReturnArgs>(args?: SelectSubset<T, PatientDocumentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientDocumentPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a PatientDocument.
     * @param {PatientDocumentDeleteArgs} args - Arguments to delete one PatientDocument.
     * @example
     * // Delete one PatientDocument
     * const PatientDocument = await prisma.patientDocument.delete({
     *   where: {
     *     // ... filter to delete one PatientDocument
     *   }
     * })
     * 
     */
    delete<T extends PatientDocumentDeleteArgs>(args: SelectSubset<T, PatientDocumentDeleteArgs<ExtArgs>>): Prisma__PatientDocumentClient<$Result.GetResult<Prisma.$PatientDocumentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more PatientDocuments and returns the data updated in the database.
     * @param {PatientDocumentUpdateManyAndReturnArgs} args - Arguments to update many PatientDocuments.
     * @example
     * // Update many PatientDocuments
     * const patientDocument = await prisma.patientDocument.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more PatientDocuments and only return the `id`
     * const patientDocumentWithIdOnly = await prisma.patientDocument.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PatientDocumentUpdateManyAndReturnArgs>(args: SelectSubset<T, PatientDocumentUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientDocumentPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PatientDocument.
   * 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__PatientDocumentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PatientDocument model
   */
  interface PatientDocumentFieldRefs {
    readonly id: FieldRef<"PatientDocument", 'Int'>
    readonly patientId: FieldRef<"PatientDocument", 'Int'>
    readonly filename: FieldRef<"PatientDocument", 'String'>
    readonly originalName: FieldRef<"PatientDocument", 'String'>
    readonly mimeType: FieldRef<"PatientDocument", 'String'>
    readonly fileSize: FieldRef<"PatientDocument", 'BigInt'>
    readonly filePath: FieldRef<"PatientDocument", 'String'>
    readonly uploadedAt: FieldRef<"PatientDocument", 'DateTime'>
    readonly updatedAt: FieldRef<"PatientDocument", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * PatientDocument findUnique
   */
  export type PatientDocumentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * Filter, which PatientDocument to fetch.
     */
    where: PatientDocumentWhereUniqueInput
  }

  /**
   * PatientDocument findUniqueOrThrow
   */
  export type PatientDocumentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * Filter, which PatientDocument to fetch.
     */
    where: PatientDocumentWhereUniqueInput
  }

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

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

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

  /**
   * PatientDocument create
   */
  export type PatientDocumentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * The data needed to create a PatientDocument.
     */
    data: XOR<PatientDocumentCreateInput, PatientDocumentUncheckedCreateInput>
  }

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

  /**
   * PatientDocument createManyAndReturn
   */
  export type PatientDocumentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * The data used to create many PatientDocuments.
     */
    data: PatientDocumentCreateManyInput | PatientDocumentCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PatientDocument update
   */
  export type PatientDocumentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * The data needed to update a PatientDocument.
     */
    data: XOR<PatientDocumentUpdateInput, PatientDocumentUncheckedUpdateInput>
    /**
     * Choose, which PatientDocument to update.
     */
    where: PatientDocumentWhereUniqueInput
  }

  /**
   * PatientDocument updateMany
   */
  export type PatientDocumentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PatientDocuments.
     */
    data: XOR<PatientDocumentUpdateManyMutationInput, PatientDocumentUncheckedUpdateManyInput>
    /**
     * Filter which PatientDocuments to update
     */
    where?: PatientDocumentWhereInput
    /**
     * Limit how many PatientDocuments to update.
     */
    limit?: number
  }

  /**
   * PatientDocument updateManyAndReturn
   */
  export type PatientDocumentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * The data used to update PatientDocuments.
     */
    data: XOR<PatientDocumentUpdateManyMutationInput, PatientDocumentUncheckedUpdateManyInput>
    /**
     * Filter which PatientDocuments to update
     */
    where?: PatientDocumentWhereInput
    /**
     * Limit how many PatientDocuments to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * PatientDocument upsert
   */
  export type PatientDocumentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * The filter to search for the PatientDocument to update in case it exists.
     */
    where: PatientDocumentWhereUniqueInput
    /**
     * In case the PatientDocument found by the `where` argument doesn't exist, create a new PatientDocument with this data.
     */
    create: XOR<PatientDocumentCreateInput, PatientDocumentUncheckedCreateInput>
    /**
     * In case the PatientDocument was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PatientDocumentUpdateInput, PatientDocumentUncheckedUpdateInput>
  }

  /**
   * PatientDocument delete
   */
  export type PatientDocumentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientDocument
     */
    select?: PatientDocumentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientDocument
     */
    omit?: PatientDocumentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientDocumentInclude<ExtArgs> | null
    /**
     * Filter which PatientDocument to delete.
     */
    where: PatientDocumentWhereUniqueInput
  }

  /**
   * PatientDocument deleteMany
   */
  export type PatientDocumentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PatientDocuments to delete
     */
    where?: PatientDocumentWhereInput
    /**
     * Limit how many PatientDocuments to delete.
     */
    limit?: number
  }

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


  /**
   * Model TwilioSettings
   */

  export type AggregateTwilioSettings = {
    _count: TwilioSettingsCountAggregateOutputType | null
    _avg: TwilioSettingsAvgAggregateOutputType | null
    _sum: TwilioSettingsSumAggregateOutputType | null
    _min: TwilioSettingsMinAggregateOutputType | null
    _max: TwilioSettingsMaxAggregateOutputType | null
  }

  export type TwilioSettingsAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type TwilioSettingsSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type TwilioSettingsMinAggregateOutputType = {
    id: number | null
    userId: number | null
    accountSid: string | null
    authToken: string | null
    phoneNumber: string | null
    greetingMessage: string | null
  }

  export type TwilioSettingsMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    accountSid: string | null
    authToken: string | null
    phoneNumber: string | null
    greetingMessage: string | null
  }

  export type TwilioSettingsCountAggregateOutputType = {
    id: number
    userId: number
    accountSid: number
    authToken: number
    phoneNumber: number
    greetingMessage: number
    templates: number
    _all: number
  }


  export type TwilioSettingsAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type TwilioSettingsSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type TwilioSettingsMinAggregateInputType = {
    id?: true
    userId?: true
    accountSid?: true
    authToken?: true
    phoneNumber?: true
    greetingMessage?: true
  }

  export type TwilioSettingsMaxAggregateInputType = {
    id?: true
    userId?: true
    accountSid?: true
    authToken?: true
    phoneNumber?: true
    greetingMessage?: true
  }

  export type TwilioSettingsCountAggregateInputType = {
    id?: true
    userId?: true
    accountSid?: true
    authToken?: true
    phoneNumber?: true
    greetingMessage?: true
    templates?: true
    _all?: true
  }

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

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




  export type TwilioSettingsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TwilioSettingsWhereInput
    orderBy?: TwilioSettingsOrderByWithAggregationInput | TwilioSettingsOrderByWithAggregationInput[]
    by: TwilioSettingsScalarFieldEnum[] | TwilioSettingsScalarFieldEnum
    having?: TwilioSettingsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TwilioSettingsCountAggregateInputType | true
    _avg?: TwilioSettingsAvgAggregateInputType
    _sum?: TwilioSettingsSumAggregateInputType
    _min?: TwilioSettingsMinAggregateInputType
    _max?: TwilioSettingsMaxAggregateInputType
  }

  export type TwilioSettingsGroupByOutputType = {
    id: number
    userId: number
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage: string | null
    templates: JsonValue | null
    _count: TwilioSettingsCountAggregateOutputType | null
    _avg: TwilioSettingsAvgAggregateOutputType | null
    _sum: TwilioSettingsSumAggregateOutputType | null
    _min: TwilioSettingsMinAggregateOutputType | null
    _max: TwilioSettingsMaxAggregateOutputType | null
  }

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


  export type TwilioSettingsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    accountSid?: boolean
    authToken?: boolean
    phoneNumber?: boolean
    greetingMessage?: boolean
    templates?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["twilioSettings"]>

  export type TwilioSettingsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    accountSid?: boolean
    authToken?: boolean
    phoneNumber?: boolean
    greetingMessage?: boolean
    templates?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["twilioSettings"]>

  export type TwilioSettingsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    accountSid?: boolean
    authToken?: boolean
    phoneNumber?: boolean
    greetingMessage?: boolean
    templates?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["twilioSettings"]>

  export type TwilioSettingsSelectScalar = {
    id?: boolean
    userId?: boolean
    accountSid?: boolean
    authToken?: boolean
    phoneNumber?: boolean
    greetingMessage?: boolean
    templates?: boolean
  }

  export type TwilioSettingsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "accountSid" | "authToken" | "phoneNumber" | "greetingMessage" | "templates", ExtArgs["result"]["twilioSettings"]>
  export type TwilioSettingsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type TwilioSettingsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type TwilioSettingsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $TwilioSettingsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TwilioSettings"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      accountSid: string
      authToken: string
      phoneNumber: string
      greetingMessage: string | null
      templates: Prisma.JsonValue | null
    }, ExtArgs["result"]["twilioSettings"]>
    composites: {}
  }

  type TwilioSettingsGetPayload<S extends boolean | null | undefined | TwilioSettingsDefaultArgs> = $Result.GetResult<Prisma.$TwilioSettingsPayload, S>

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

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

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

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

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

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

    /**
     * Create a TwilioSettings.
     * @param {TwilioSettingsCreateArgs} args - Arguments to create a TwilioSettings.
     * @example
     * // Create one TwilioSettings
     * const TwilioSettings = await prisma.twilioSettings.create({
     *   data: {
     *     // ... data to create a TwilioSettings
     *   }
     * })
     * 
     */
    create<T extends TwilioSettingsCreateArgs>(args: SelectSubset<T, TwilioSettingsCreateArgs<ExtArgs>>): Prisma__TwilioSettingsClient<$Result.GetResult<Prisma.$TwilioSettingsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TwilioSettings and returns the data saved in the database.
     * @param {TwilioSettingsCreateManyAndReturnArgs} args - Arguments to create many TwilioSettings.
     * @example
     * // Create many TwilioSettings
     * const twilioSettings = await prisma.twilioSettings.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TwilioSettings and only return the `id`
     * const twilioSettingsWithIdOnly = await prisma.twilioSettings.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 TwilioSettingsCreateManyAndReturnArgs>(args?: SelectSubset<T, TwilioSettingsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TwilioSettingsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TwilioSettings.
     * @param {TwilioSettingsDeleteArgs} args - Arguments to delete one TwilioSettings.
     * @example
     * // Delete one TwilioSettings
     * const TwilioSettings = await prisma.twilioSettings.delete({
     *   where: {
     *     // ... filter to delete one TwilioSettings
     *   }
     * })
     * 
     */
    delete<T extends TwilioSettingsDeleteArgs>(args: SelectSubset<T, TwilioSettingsDeleteArgs<ExtArgs>>): Prisma__TwilioSettingsClient<$Result.GetResult<Prisma.$TwilioSettingsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more TwilioSettings and returns the data updated in the database.
     * @param {TwilioSettingsUpdateManyAndReturnArgs} args - Arguments to update many TwilioSettings.
     * @example
     * // Update many TwilioSettings
     * const twilioSettings = await prisma.twilioSettings.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more TwilioSettings and only return the `id`
     * const twilioSettingsWithIdOnly = await prisma.twilioSettings.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends TwilioSettingsUpdateManyAndReturnArgs>(args: SelectSubset<T, TwilioSettingsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TwilioSettingsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for TwilioSettings.
   * 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__TwilioSettingsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the TwilioSettings model
   */
  interface TwilioSettingsFieldRefs {
    readonly id: FieldRef<"TwilioSettings", 'Int'>
    readonly userId: FieldRef<"TwilioSettings", 'Int'>
    readonly accountSid: FieldRef<"TwilioSettings", 'String'>
    readonly authToken: FieldRef<"TwilioSettings", 'String'>
    readonly phoneNumber: FieldRef<"TwilioSettings", 'String'>
    readonly greetingMessage: FieldRef<"TwilioSettings", 'String'>
    readonly templates: FieldRef<"TwilioSettings", 'Json'>
  }
    

  // Custom InputTypes
  /**
   * TwilioSettings findUnique
   */
  export type TwilioSettingsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * Filter, which TwilioSettings to fetch.
     */
    where: TwilioSettingsWhereUniqueInput
  }

  /**
   * TwilioSettings findUniqueOrThrow
   */
  export type TwilioSettingsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * Filter, which TwilioSettings to fetch.
     */
    where: TwilioSettingsWhereUniqueInput
  }

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

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

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

  /**
   * TwilioSettings create
   */
  export type TwilioSettingsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * The data needed to create a TwilioSettings.
     */
    data: XOR<TwilioSettingsCreateInput, TwilioSettingsUncheckedCreateInput>
  }

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

  /**
   * TwilioSettings createManyAndReturn
   */
  export type TwilioSettingsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * The data used to create many TwilioSettings.
     */
    data: TwilioSettingsCreateManyInput | TwilioSettingsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * TwilioSettings update
   */
  export type TwilioSettingsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * The data needed to update a TwilioSettings.
     */
    data: XOR<TwilioSettingsUpdateInput, TwilioSettingsUncheckedUpdateInput>
    /**
     * Choose, which TwilioSettings to update.
     */
    where: TwilioSettingsWhereUniqueInput
  }

  /**
   * TwilioSettings updateMany
   */
  export type TwilioSettingsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TwilioSettings.
     */
    data: XOR<TwilioSettingsUpdateManyMutationInput, TwilioSettingsUncheckedUpdateManyInput>
    /**
     * Filter which TwilioSettings to update
     */
    where?: TwilioSettingsWhereInput
    /**
     * Limit how many TwilioSettings to update.
     */
    limit?: number
  }

  /**
   * TwilioSettings updateManyAndReturn
   */
  export type TwilioSettingsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * The data used to update TwilioSettings.
     */
    data: XOR<TwilioSettingsUpdateManyMutationInput, TwilioSettingsUncheckedUpdateManyInput>
    /**
     * Filter which TwilioSettings to update
     */
    where?: TwilioSettingsWhereInput
    /**
     * Limit how many TwilioSettings to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * TwilioSettings upsert
   */
  export type TwilioSettingsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * The filter to search for the TwilioSettings to update in case it exists.
     */
    where: TwilioSettingsWhereUniqueInput
    /**
     * In case the TwilioSettings found by the `where` argument doesn't exist, create a new TwilioSettings with this data.
     */
    create: XOR<TwilioSettingsCreateInput, TwilioSettingsUncheckedCreateInput>
    /**
     * In case the TwilioSettings was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TwilioSettingsUpdateInput, TwilioSettingsUncheckedUpdateInput>
  }

  /**
   * TwilioSettings delete
   */
  export type TwilioSettingsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TwilioSettings
     */
    select?: TwilioSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TwilioSettings
     */
    omit?: TwilioSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TwilioSettingsInclude<ExtArgs> | null
    /**
     * Filter which TwilioSettings to delete.
     */
    where: TwilioSettingsWhereUniqueInput
  }

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

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


  /**
   * Model AiSettings
   */

  export type AggregateAiSettings = {
    _count: AiSettingsCountAggregateOutputType | null
    _avg: AiSettingsAvgAggregateOutputType | null
    _sum: AiSettingsSumAggregateOutputType | null
    _min: AiSettingsMinAggregateOutputType | null
    _max: AiSettingsMaxAggregateOutputType | null
  }

  export type AiSettingsAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type AiSettingsSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type AiSettingsMinAggregateOutputType = {
    id: number | null
    userId: number | null
    apiKey: string | null
    afterHoursEnabled: boolean | null
    openPhoneReply: boolean | null
  }

  export type AiSettingsMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    apiKey: string | null
    afterHoursEnabled: boolean | null
    openPhoneReply: boolean | null
  }

  export type AiSettingsCountAggregateOutputType = {
    id: number
    userId: number
    apiKey: number
    afterHoursEnabled: number
    openPhoneReply: number
    _all: number
  }


  export type AiSettingsAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type AiSettingsSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type AiSettingsMinAggregateInputType = {
    id?: true
    userId?: true
    apiKey?: true
    afterHoursEnabled?: true
    openPhoneReply?: true
  }

  export type AiSettingsMaxAggregateInputType = {
    id?: true
    userId?: true
    apiKey?: true
    afterHoursEnabled?: true
    openPhoneReply?: true
  }

  export type AiSettingsCountAggregateInputType = {
    id?: true
    userId?: true
    apiKey?: true
    afterHoursEnabled?: true
    openPhoneReply?: true
    _all?: true
  }

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

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




  export type AiSettingsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AiSettingsWhereInput
    orderBy?: AiSettingsOrderByWithAggregationInput | AiSettingsOrderByWithAggregationInput[]
    by: AiSettingsScalarFieldEnum[] | AiSettingsScalarFieldEnum
    having?: AiSettingsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AiSettingsCountAggregateInputType | true
    _avg?: AiSettingsAvgAggregateInputType
    _sum?: AiSettingsSumAggregateInputType
    _min?: AiSettingsMinAggregateInputType
    _max?: AiSettingsMaxAggregateInputType
  }

  export type AiSettingsGroupByOutputType = {
    id: number
    userId: number
    apiKey: string
    afterHoursEnabled: boolean
    openPhoneReply: boolean
    _count: AiSettingsCountAggregateOutputType | null
    _avg: AiSettingsAvgAggregateOutputType | null
    _sum: AiSettingsSumAggregateOutputType | null
    _min: AiSettingsMinAggregateOutputType | null
    _max: AiSettingsMaxAggregateOutputType | null
  }

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


  export type AiSettingsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    apiKey?: boolean
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["aiSettings"]>

  export type AiSettingsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    apiKey?: boolean
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["aiSettings"]>

  export type AiSettingsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    apiKey?: boolean
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["aiSettings"]>

  export type AiSettingsSelectScalar = {
    id?: boolean
    userId?: boolean
    apiKey?: boolean
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
  }

  export type AiSettingsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "apiKey" | "afterHoursEnabled" | "openPhoneReply", ExtArgs["result"]["aiSettings"]>
  export type AiSettingsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AiSettingsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AiSettingsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AiSettingsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AiSettings"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      apiKey: string
      afterHoursEnabled: boolean
      openPhoneReply: boolean
    }, ExtArgs["result"]["aiSettings"]>
    composites: {}
  }

  type AiSettingsGetPayload<S extends boolean | null | undefined | AiSettingsDefaultArgs> = $Result.GetResult<Prisma.$AiSettingsPayload, S>

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

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

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

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

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

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

    /**
     * Create a AiSettings.
     * @param {AiSettingsCreateArgs} args - Arguments to create a AiSettings.
     * @example
     * // Create one AiSettings
     * const AiSettings = await prisma.aiSettings.create({
     *   data: {
     *     // ... data to create a AiSettings
     *   }
     * })
     * 
     */
    create<T extends AiSettingsCreateArgs>(args: SelectSubset<T, AiSettingsCreateArgs<ExtArgs>>): Prisma__AiSettingsClient<$Result.GetResult<Prisma.$AiSettingsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AiSettings and returns the data saved in the database.
     * @param {AiSettingsCreateManyAndReturnArgs} args - Arguments to create many AiSettings.
     * @example
     * // Create many AiSettings
     * const aiSettings = await prisma.aiSettings.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AiSettings and only return the `id`
     * const aiSettingsWithIdOnly = await prisma.aiSettings.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 AiSettingsCreateManyAndReturnArgs>(args?: SelectSubset<T, AiSettingsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AiSettingsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AiSettings.
     * @param {AiSettingsDeleteArgs} args - Arguments to delete one AiSettings.
     * @example
     * // Delete one AiSettings
     * const AiSettings = await prisma.aiSettings.delete({
     *   where: {
     *     // ... filter to delete one AiSettings
     *   }
     * })
     * 
     */
    delete<T extends AiSettingsDeleteArgs>(args: SelectSubset<T, AiSettingsDeleteArgs<ExtArgs>>): Prisma__AiSettingsClient<$Result.GetResult<Prisma.$AiSettingsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more AiSettings and returns the data updated in the database.
     * @param {AiSettingsUpdateManyAndReturnArgs} args - Arguments to update many AiSettings.
     * @example
     * // Update many AiSettings
     * const aiSettings = await prisma.aiSettings.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AiSettings and only return the `id`
     * const aiSettingsWithIdOnly = await prisma.aiSettings.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AiSettingsUpdateManyAndReturnArgs>(args: SelectSubset<T, AiSettingsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AiSettingsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AiSettings.
   * 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__AiSettingsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the AiSettings model
   */
  interface AiSettingsFieldRefs {
    readonly id: FieldRef<"AiSettings", 'Int'>
    readonly userId: FieldRef<"AiSettings", 'Int'>
    readonly apiKey: FieldRef<"AiSettings", 'String'>
    readonly afterHoursEnabled: FieldRef<"AiSettings", 'Boolean'>
    readonly openPhoneReply: FieldRef<"AiSettings", 'Boolean'>
  }
    

  // Custom InputTypes
  /**
   * AiSettings findUnique
   */
  export type AiSettingsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * Filter, which AiSettings to fetch.
     */
    where: AiSettingsWhereUniqueInput
  }

  /**
   * AiSettings findUniqueOrThrow
   */
  export type AiSettingsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * Filter, which AiSettings to fetch.
     */
    where: AiSettingsWhereUniqueInput
  }

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

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

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

  /**
   * AiSettings create
   */
  export type AiSettingsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * The data needed to create a AiSettings.
     */
    data: XOR<AiSettingsCreateInput, AiSettingsUncheckedCreateInput>
  }

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

  /**
   * AiSettings createManyAndReturn
   */
  export type AiSettingsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * The data used to create many AiSettings.
     */
    data: AiSettingsCreateManyInput | AiSettingsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AiSettings update
   */
  export type AiSettingsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * The data needed to update a AiSettings.
     */
    data: XOR<AiSettingsUpdateInput, AiSettingsUncheckedUpdateInput>
    /**
     * Choose, which AiSettings to update.
     */
    where: AiSettingsWhereUniqueInput
  }

  /**
   * AiSettings updateMany
   */
  export type AiSettingsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AiSettings.
     */
    data: XOR<AiSettingsUpdateManyMutationInput, AiSettingsUncheckedUpdateManyInput>
    /**
     * Filter which AiSettings to update
     */
    where?: AiSettingsWhereInput
    /**
     * Limit how many AiSettings to update.
     */
    limit?: number
  }

  /**
   * AiSettings updateManyAndReturn
   */
  export type AiSettingsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * The data used to update AiSettings.
     */
    data: XOR<AiSettingsUpdateManyMutationInput, AiSettingsUncheckedUpdateManyInput>
    /**
     * Filter which AiSettings to update
     */
    where?: AiSettingsWhereInput
    /**
     * Limit how many AiSettings to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * AiSettings upsert
   */
  export type AiSettingsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * The filter to search for the AiSettings to update in case it exists.
     */
    where: AiSettingsWhereUniqueInput
    /**
     * In case the AiSettings found by the `where` argument doesn't exist, create a new AiSettings with this data.
     */
    create: XOR<AiSettingsCreateInput, AiSettingsUncheckedCreateInput>
    /**
     * In case the AiSettings was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AiSettingsUpdateInput, AiSettingsUncheckedUpdateInput>
  }

  /**
   * AiSettings delete
   */
  export type AiSettingsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AiSettings
     */
    select?: AiSettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AiSettings
     */
    omit?: AiSettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AiSettingsInclude<ExtArgs> | null
    /**
     * Filter which AiSettings to delete.
     */
    where: AiSettingsWhereUniqueInput
  }

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

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


  /**
   * Model OfficeHours
   */

  export type AggregateOfficeHours = {
    _count: OfficeHoursCountAggregateOutputType | null
    _avg: OfficeHoursAvgAggregateOutputType | null
    _sum: OfficeHoursSumAggregateOutputType | null
    _min: OfficeHoursMinAggregateOutputType | null
    _max: OfficeHoursMaxAggregateOutputType | null
  }

  export type OfficeHoursAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeHoursSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeHoursMinAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeHoursMaxAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeHoursCountAggregateOutputType = {
    id: number
    userId: number
    data: number
    _all: number
  }


  export type OfficeHoursAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeHoursSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeHoursMinAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeHoursMaxAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeHoursCountAggregateInputType = {
    id?: true
    userId?: true
    data?: true
    _all?: true
  }

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

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




  export type OfficeHoursGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OfficeHoursWhereInput
    orderBy?: OfficeHoursOrderByWithAggregationInput | OfficeHoursOrderByWithAggregationInput[]
    by: OfficeHoursScalarFieldEnum[] | OfficeHoursScalarFieldEnum
    having?: OfficeHoursScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OfficeHoursCountAggregateInputType | true
    _avg?: OfficeHoursAvgAggregateInputType
    _sum?: OfficeHoursSumAggregateInputType
    _min?: OfficeHoursMinAggregateInputType
    _max?: OfficeHoursMaxAggregateInputType
  }

  export type OfficeHoursGroupByOutputType = {
    id: number
    userId: number
    data: JsonValue
    _count: OfficeHoursCountAggregateOutputType | null
    _avg: OfficeHoursAvgAggregateOutputType | null
    _sum: OfficeHoursSumAggregateOutputType | null
    _min: OfficeHoursMinAggregateOutputType | null
    _max: OfficeHoursMaxAggregateOutputType | null
  }

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


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

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

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

  export type OfficeHoursSelectScalar = {
    id?: boolean
    userId?: boolean
    data?: boolean
  }

  export type OfficeHoursOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "data", ExtArgs["result"]["officeHours"]>
  export type OfficeHoursInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type OfficeHoursIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type OfficeHoursIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $OfficeHoursPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OfficeHours"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      data: Prisma.JsonValue
    }, ExtArgs["result"]["officeHours"]>
    composites: {}
  }

  type OfficeHoursGetPayload<S extends boolean | null | undefined | OfficeHoursDefaultArgs> = $Result.GetResult<Prisma.$OfficeHoursPayload, S>

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

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

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

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

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

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

    /**
     * Create a OfficeHours.
     * @param {OfficeHoursCreateArgs} args - Arguments to create a OfficeHours.
     * @example
     * // Create one OfficeHours
     * const OfficeHours = await prisma.officeHours.create({
     *   data: {
     *     // ... data to create a OfficeHours
     *   }
     * })
     * 
     */
    create<T extends OfficeHoursCreateArgs>(args: SelectSubset<T, OfficeHoursCreateArgs<ExtArgs>>): Prisma__OfficeHoursClient<$Result.GetResult<Prisma.$OfficeHoursPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many OfficeHours and returns the data saved in the database.
     * @param {OfficeHoursCreateManyAndReturnArgs} args - Arguments to create many OfficeHours.
     * @example
     * // Create many OfficeHours
     * const officeHours = await prisma.officeHours.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many OfficeHours and only return the `id`
     * const officeHoursWithIdOnly = await prisma.officeHours.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 OfficeHoursCreateManyAndReturnArgs>(args?: SelectSubset<T, OfficeHoursCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OfficeHoursPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a OfficeHours.
     * @param {OfficeHoursDeleteArgs} args - Arguments to delete one OfficeHours.
     * @example
     * // Delete one OfficeHours
     * const OfficeHours = await prisma.officeHours.delete({
     *   where: {
     *     // ... filter to delete one OfficeHours
     *   }
     * })
     * 
     */
    delete<T extends OfficeHoursDeleteArgs>(args: SelectSubset<T, OfficeHoursDeleteArgs<ExtArgs>>): Prisma__OfficeHoursClient<$Result.GetResult<Prisma.$OfficeHoursPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more OfficeHours and returns the data updated in the database.
     * @param {OfficeHoursUpdateManyAndReturnArgs} args - Arguments to update many OfficeHours.
     * @example
     * // Update many OfficeHours
     * const officeHours = await prisma.officeHours.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more OfficeHours and only return the `id`
     * const officeHoursWithIdOnly = await prisma.officeHours.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends OfficeHoursUpdateManyAndReturnArgs>(args: SelectSubset<T, OfficeHoursUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OfficeHoursPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OfficeHours.
   * 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__OfficeHoursClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the OfficeHours model
   */
  interface OfficeHoursFieldRefs {
    readonly id: FieldRef<"OfficeHours", 'Int'>
    readonly userId: FieldRef<"OfficeHours", 'Int'>
    readonly data: FieldRef<"OfficeHours", 'Json'>
  }
    

  // Custom InputTypes
  /**
   * OfficeHours findUnique
   */
  export type OfficeHoursFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * Filter, which OfficeHours to fetch.
     */
    where: OfficeHoursWhereUniqueInput
  }

  /**
   * OfficeHours findUniqueOrThrow
   */
  export type OfficeHoursFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * Filter, which OfficeHours to fetch.
     */
    where: OfficeHoursWhereUniqueInput
  }

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

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

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

  /**
   * OfficeHours create
   */
  export type OfficeHoursCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * The data needed to create a OfficeHours.
     */
    data: XOR<OfficeHoursCreateInput, OfficeHoursUncheckedCreateInput>
  }

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

  /**
   * OfficeHours createManyAndReturn
   */
  export type OfficeHoursCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * The data used to create many OfficeHours.
     */
    data: OfficeHoursCreateManyInput | OfficeHoursCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * OfficeHours update
   */
  export type OfficeHoursUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * The data needed to update a OfficeHours.
     */
    data: XOR<OfficeHoursUpdateInput, OfficeHoursUncheckedUpdateInput>
    /**
     * Choose, which OfficeHours to update.
     */
    where: OfficeHoursWhereUniqueInput
  }

  /**
   * OfficeHours updateMany
   */
  export type OfficeHoursUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OfficeHours.
     */
    data: XOR<OfficeHoursUpdateManyMutationInput, OfficeHoursUncheckedUpdateManyInput>
    /**
     * Filter which OfficeHours to update
     */
    where?: OfficeHoursWhereInput
    /**
     * Limit how many OfficeHours to update.
     */
    limit?: number
  }

  /**
   * OfficeHours updateManyAndReturn
   */
  export type OfficeHoursUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * The data used to update OfficeHours.
     */
    data: XOR<OfficeHoursUpdateManyMutationInput, OfficeHoursUncheckedUpdateManyInput>
    /**
     * Filter which OfficeHours to update
     */
    where?: OfficeHoursWhereInput
    /**
     * Limit how many OfficeHours to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * OfficeHours upsert
   */
  export type OfficeHoursUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * The filter to search for the OfficeHours to update in case it exists.
     */
    where: OfficeHoursWhereUniqueInput
    /**
     * In case the OfficeHours found by the `where` argument doesn't exist, create a new OfficeHours with this data.
     */
    create: XOR<OfficeHoursCreateInput, OfficeHoursUncheckedCreateInput>
    /**
     * In case the OfficeHours was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OfficeHoursUpdateInput, OfficeHoursUncheckedUpdateInput>
  }

  /**
   * OfficeHours delete
   */
  export type OfficeHoursDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeHours
     */
    select?: OfficeHoursSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeHours
     */
    omit?: OfficeHoursOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeHoursInclude<ExtArgs> | null
    /**
     * Filter which OfficeHours to delete.
     */
    where: OfficeHoursWhereUniqueInput
  }

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

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


  /**
   * Model OfficeContact
   */

  export type AggregateOfficeContact = {
    _count: OfficeContactCountAggregateOutputType | null
    _avg: OfficeContactAvgAggregateOutputType | null
    _sum: OfficeContactSumAggregateOutputType | null
    _min: OfficeContactMinAggregateOutputType | null
    _max: OfficeContactMaxAggregateOutputType | null
  }

  export type OfficeContactAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeContactSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type OfficeContactMinAggregateOutputType = {
    id: number | null
    userId: number | null
    officeName: string | null
    receptionistName: string | null
    dentistName: string | null
    phoneNumber: string | null
    email: string | null
    fax: string | null
    streetAddress: string | null
    city: string | null
    state: string | null
    zipCode: string | null
  }

  export type OfficeContactMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    officeName: string | null
    receptionistName: string | null
    dentistName: string | null
    phoneNumber: string | null
    email: string | null
    fax: string | null
    streetAddress: string | null
    city: string | null
    state: string | null
    zipCode: string | null
  }

  export type OfficeContactCountAggregateOutputType = {
    id: number
    userId: number
    officeName: number
    receptionistName: number
    dentistName: number
    phoneNumber: number
    email: number
    fax: number
    streetAddress: number
    city: number
    state: number
    zipCode: number
    _all: number
  }


  export type OfficeContactAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeContactSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type OfficeContactMinAggregateInputType = {
    id?: true
    userId?: true
    officeName?: true
    receptionistName?: true
    dentistName?: true
    phoneNumber?: true
    email?: true
    fax?: true
    streetAddress?: true
    city?: true
    state?: true
    zipCode?: true
  }

  export type OfficeContactMaxAggregateInputType = {
    id?: true
    userId?: true
    officeName?: true
    receptionistName?: true
    dentistName?: true
    phoneNumber?: true
    email?: true
    fax?: true
    streetAddress?: true
    city?: true
    state?: true
    zipCode?: true
  }

  export type OfficeContactCountAggregateInputType = {
    id?: true
    userId?: true
    officeName?: true
    receptionistName?: true
    dentistName?: true
    phoneNumber?: true
    email?: true
    fax?: true
    streetAddress?: true
    city?: true
    state?: true
    zipCode?: true
    _all?: true
  }

  export type OfficeContactAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OfficeContact to aggregate.
     */
    where?: OfficeContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of OfficeContacts to fetch.
     */
    orderBy?: OfficeContactOrderByWithRelationInput | OfficeContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: OfficeContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` OfficeContacts 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` OfficeContacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned OfficeContacts
    **/
    _count?: true | OfficeContactCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: OfficeContactAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: OfficeContactSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OfficeContactMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OfficeContactMaxAggregateInputType
  }

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




  export type OfficeContactGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OfficeContactWhereInput
    orderBy?: OfficeContactOrderByWithAggregationInput | OfficeContactOrderByWithAggregationInput[]
    by: OfficeContactScalarFieldEnum[] | OfficeContactScalarFieldEnum
    having?: OfficeContactScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OfficeContactCountAggregateInputType | true
    _avg?: OfficeContactAvgAggregateInputType
    _sum?: OfficeContactSumAggregateInputType
    _min?: OfficeContactMinAggregateInputType
    _max?: OfficeContactMaxAggregateInputType
  }

  export type OfficeContactGroupByOutputType = {
    id: number
    userId: number
    officeName: string | null
    receptionistName: string | null
    dentistName: string | null
    phoneNumber: string | null
    email: string | null
    fax: string | null
    streetAddress: string | null
    city: string | null
    state: string | null
    zipCode: string | null
    _count: OfficeContactCountAggregateOutputType | null
    _avg: OfficeContactAvgAggregateOutputType | null
    _sum: OfficeContactSumAggregateOutputType | null
    _min: OfficeContactMinAggregateOutputType | null
    _max: OfficeContactMaxAggregateOutputType | null
  }

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


  export type OfficeContactSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    officeName?: boolean
    receptionistName?: boolean
    dentistName?: boolean
    phoneNumber?: boolean
    email?: boolean
    fax?: boolean
    streetAddress?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["officeContact"]>

  export type OfficeContactSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    officeName?: boolean
    receptionistName?: boolean
    dentistName?: boolean
    phoneNumber?: boolean
    email?: boolean
    fax?: boolean
    streetAddress?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["officeContact"]>

  export type OfficeContactSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    officeName?: boolean
    receptionistName?: boolean
    dentistName?: boolean
    phoneNumber?: boolean
    email?: boolean
    fax?: boolean
    streetAddress?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["officeContact"]>

  export type OfficeContactSelectScalar = {
    id?: boolean
    userId?: boolean
    officeName?: boolean
    receptionistName?: boolean
    dentistName?: boolean
    phoneNumber?: boolean
    email?: boolean
    fax?: boolean
    streetAddress?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
  }

  export type OfficeContactOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "officeName" | "receptionistName" | "dentistName" | "phoneNumber" | "email" | "fax" | "streetAddress" | "city" | "state" | "zipCode", ExtArgs["result"]["officeContact"]>
  export type OfficeContactInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type OfficeContactIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type OfficeContactIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $OfficeContactPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OfficeContact"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      officeName: string | null
      receptionistName: string | null
      dentistName: string | null
      phoneNumber: string | null
      email: string | null
      fax: string | null
      streetAddress: string | null
      city: string | null
      state: string | null
      zipCode: string | null
    }, ExtArgs["result"]["officeContact"]>
    composites: {}
  }

  type OfficeContactGetPayload<S extends boolean | null | undefined | OfficeContactDefaultArgs> = $Result.GetResult<Prisma.$OfficeContactPayload, S>

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

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

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

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

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

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

    /**
     * Create a OfficeContact.
     * @param {OfficeContactCreateArgs} args - Arguments to create a OfficeContact.
     * @example
     * // Create one OfficeContact
     * const OfficeContact = await prisma.officeContact.create({
     *   data: {
     *     // ... data to create a OfficeContact
     *   }
     * })
     * 
     */
    create<T extends OfficeContactCreateArgs>(args: SelectSubset<T, OfficeContactCreateArgs<ExtArgs>>): Prisma__OfficeContactClient<$Result.GetResult<Prisma.$OfficeContactPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many OfficeContacts and returns the data saved in the database.
     * @param {OfficeContactCreateManyAndReturnArgs} args - Arguments to create many OfficeContacts.
     * @example
     * // Create many OfficeContacts
     * const officeContact = await prisma.officeContact.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many OfficeContacts and only return the `id`
     * const officeContactWithIdOnly = await prisma.officeContact.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 OfficeContactCreateManyAndReturnArgs>(args?: SelectSubset<T, OfficeContactCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OfficeContactPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a OfficeContact.
     * @param {OfficeContactDeleteArgs} args - Arguments to delete one OfficeContact.
     * @example
     * // Delete one OfficeContact
     * const OfficeContact = await prisma.officeContact.delete({
     *   where: {
     *     // ... filter to delete one OfficeContact
     *   }
     * })
     * 
     */
    delete<T extends OfficeContactDeleteArgs>(args: SelectSubset<T, OfficeContactDeleteArgs<ExtArgs>>): Prisma__OfficeContactClient<$Result.GetResult<Prisma.$OfficeContactPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more OfficeContacts and returns the data updated in the database.
     * @param {OfficeContactUpdateManyAndReturnArgs} args - Arguments to update many OfficeContacts.
     * @example
     * // Update many OfficeContacts
     * const officeContact = await prisma.officeContact.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more OfficeContacts and only return the `id`
     * const officeContactWithIdOnly = await prisma.officeContact.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends OfficeContactUpdateManyAndReturnArgs>(args: SelectSubset<T, OfficeContactUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OfficeContactPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OfficeContact.
   * 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__OfficeContactClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the OfficeContact model
   */
  interface OfficeContactFieldRefs {
    readonly id: FieldRef<"OfficeContact", 'Int'>
    readonly userId: FieldRef<"OfficeContact", 'Int'>
    readonly officeName: FieldRef<"OfficeContact", 'String'>
    readonly receptionistName: FieldRef<"OfficeContact", 'String'>
    readonly dentistName: FieldRef<"OfficeContact", 'String'>
    readonly phoneNumber: FieldRef<"OfficeContact", 'String'>
    readonly email: FieldRef<"OfficeContact", 'String'>
    readonly fax: FieldRef<"OfficeContact", 'String'>
    readonly streetAddress: FieldRef<"OfficeContact", 'String'>
    readonly city: FieldRef<"OfficeContact", 'String'>
    readonly state: FieldRef<"OfficeContact", 'String'>
    readonly zipCode: FieldRef<"OfficeContact", 'String'>
  }
    

  // Custom InputTypes
  /**
   * OfficeContact findUnique
   */
  export type OfficeContactFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * Filter, which OfficeContact to fetch.
     */
    where: OfficeContactWhereUniqueInput
  }

  /**
   * OfficeContact findUniqueOrThrow
   */
  export type OfficeContactFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * Filter, which OfficeContact to fetch.
     */
    where: OfficeContactWhereUniqueInput
  }

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

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

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

  /**
   * OfficeContact create
   */
  export type OfficeContactCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * The data needed to create a OfficeContact.
     */
    data: XOR<OfficeContactCreateInput, OfficeContactUncheckedCreateInput>
  }

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

  /**
   * OfficeContact createManyAndReturn
   */
  export type OfficeContactCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * The data used to create many OfficeContacts.
     */
    data: OfficeContactCreateManyInput | OfficeContactCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * OfficeContact update
   */
  export type OfficeContactUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * The data needed to update a OfficeContact.
     */
    data: XOR<OfficeContactUpdateInput, OfficeContactUncheckedUpdateInput>
    /**
     * Choose, which OfficeContact to update.
     */
    where: OfficeContactWhereUniqueInput
  }

  /**
   * OfficeContact updateMany
   */
  export type OfficeContactUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OfficeContacts.
     */
    data: XOR<OfficeContactUpdateManyMutationInput, OfficeContactUncheckedUpdateManyInput>
    /**
     * Filter which OfficeContacts to update
     */
    where?: OfficeContactWhereInput
    /**
     * Limit how many OfficeContacts to update.
     */
    limit?: number
  }

  /**
   * OfficeContact updateManyAndReturn
   */
  export type OfficeContactUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * The data used to update OfficeContacts.
     */
    data: XOR<OfficeContactUpdateManyMutationInput, OfficeContactUncheckedUpdateManyInput>
    /**
     * Filter which OfficeContacts to update
     */
    where?: OfficeContactWhereInput
    /**
     * Limit how many OfficeContacts to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * OfficeContact upsert
   */
  export type OfficeContactUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * The filter to search for the OfficeContact to update in case it exists.
     */
    where: OfficeContactWhereUniqueInput
    /**
     * In case the OfficeContact found by the `where` argument doesn't exist, create a new OfficeContact with this data.
     */
    create: XOR<OfficeContactCreateInput, OfficeContactUncheckedCreateInput>
    /**
     * In case the OfficeContact was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OfficeContactUpdateInput, OfficeContactUncheckedUpdateInput>
  }

  /**
   * OfficeContact delete
   */
  export type OfficeContactDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OfficeContact
     */
    select?: OfficeContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the OfficeContact
     */
    omit?: OfficeContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OfficeContactInclude<ExtArgs> | null
    /**
     * Filter which OfficeContact to delete.
     */
    where: OfficeContactWhereUniqueInput
  }

  /**
   * OfficeContact deleteMany
   */
  export type OfficeContactDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OfficeContacts to delete
     */
    where?: OfficeContactWhereInput
    /**
     * Limit how many OfficeContacts to delete.
     */
    limit?: number
  }

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


  /**
   * Model InsuranceContact
   */

  export type AggregateInsuranceContact = {
    _count: InsuranceContactCountAggregateOutputType | null
    _avg: InsuranceContactAvgAggregateOutputType | null
    _sum: InsuranceContactSumAggregateOutputType | null
    _min: InsuranceContactMinAggregateOutputType | null
    _max: InsuranceContactMaxAggregateOutputType | null
  }

  export type InsuranceContactAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type InsuranceContactSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type InsuranceContactMinAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    phoneNumber: string | null
    createdAt: Date | null
  }

  export type InsuranceContactMaxAggregateOutputType = {
    id: number | null
    userId: number | null
    name: string | null
    phoneNumber: string | null
    createdAt: Date | null
  }

  export type InsuranceContactCountAggregateOutputType = {
    id: number
    userId: number
    name: number
    phoneNumber: number
    createdAt: number
    _all: number
  }


  export type InsuranceContactAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type InsuranceContactSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type InsuranceContactMinAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    phoneNumber?: true
    createdAt?: true
  }

  export type InsuranceContactMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    phoneNumber?: true
    createdAt?: true
  }

  export type InsuranceContactCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    phoneNumber?: true
    createdAt?: true
    _all?: true
  }

  export type InsuranceContactAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InsuranceContact to aggregate.
     */
    where?: InsuranceContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InsuranceContacts to fetch.
     */
    orderBy?: InsuranceContactOrderByWithRelationInput | InsuranceContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: InsuranceContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InsuranceContacts 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` InsuranceContacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned InsuranceContacts
    **/
    _count?: true | InsuranceContactCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: InsuranceContactAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: InsuranceContactSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: InsuranceContactMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: InsuranceContactMaxAggregateInputType
  }

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




  export type InsuranceContactGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: InsuranceContactWhereInput
    orderBy?: InsuranceContactOrderByWithAggregationInput | InsuranceContactOrderByWithAggregationInput[]
    by: InsuranceContactScalarFieldEnum[] | InsuranceContactScalarFieldEnum
    having?: InsuranceContactScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: InsuranceContactCountAggregateInputType | true
    _avg?: InsuranceContactAvgAggregateInputType
    _sum?: InsuranceContactSumAggregateInputType
    _min?: InsuranceContactMinAggregateInputType
    _max?: InsuranceContactMaxAggregateInputType
  }

  export type InsuranceContactGroupByOutputType = {
    id: number
    userId: number
    name: string
    phoneNumber: string | null
    createdAt: Date
    _count: InsuranceContactCountAggregateOutputType | null
    _avg: InsuranceContactAvgAggregateOutputType | null
    _sum: InsuranceContactSumAggregateOutputType | null
    _min: InsuranceContactMinAggregateOutputType | null
    _max: InsuranceContactMaxAggregateOutputType | null
  }

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


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

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

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

  export type InsuranceContactSelectScalar = {
    id?: boolean
    userId?: boolean
    name?: boolean
    phoneNumber?: boolean
    createdAt?: boolean
  }

  export type InsuranceContactOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "name" | "phoneNumber" | "createdAt", ExtArgs["result"]["insuranceContact"]>
  export type InsuranceContactInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type InsuranceContactIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type InsuranceContactIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $InsuranceContactPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "InsuranceContact"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      name: string
      phoneNumber: string | null
      createdAt: Date
    }, ExtArgs["result"]["insuranceContact"]>
    composites: {}
  }

  type InsuranceContactGetPayload<S extends boolean | null | undefined | InsuranceContactDefaultArgs> = $Result.GetResult<Prisma.$InsuranceContactPayload, S>

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

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

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

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

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

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

    /**
     * Create a InsuranceContact.
     * @param {InsuranceContactCreateArgs} args - Arguments to create a InsuranceContact.
     * @example
     * // Create one InsuranceContact
     * const InsuranceContact = await prisma.insuranceContact.create({
     *   data: {
     *     // ... data to create a InsuranceContact
     *   }
     * })
     * 
     */
    create<T extends InsuranceContactCreateArgs>(args: SelectSubset<T, InsuranceContactCreateArgs<ExtArgs>>): Prisma__InsuranceContactClient<$Result.GetResult<Prisma.$InsuranceContactPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many InsuranceContacts and returns the data saved in the database.
     * @param {InsuranceContactCreateManyAndReturnArgs} args - Arguments to create many InsuranceContacts.
     * @example
     * // Create many InsuranceContacts
     * const insuranceContact = await prisma.insuranceContact.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many InsuranceContacts and only return the `id`
     * const insuranceContactWithIdOnly = await prisma.insuranceContact.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 InsuranceContactCreateManyAndReturnArgs>(args?: SelectSubset<T, InsuranceContactCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceContactPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a InsuranceContact.
     * @param {InsuranceContactDeleteArgs} args - Arguments to delete one InsuranceContact.
     * @example
     * // Delete one InsuranceContact
     * const InsuranceContact = await prisma.insuranceContact.delete({
     *   where: {
     *     // ... filter to delete one InsuranceContact
     *   }
     * })
     * 
     */
    delete<T extends InsuranceContactDeleteArgs>(args: SelectSubset<T, InsuranceContactDeleteArgs<ExtArgs>>): Prisma__InsuranceContactClient<$Result.GetResult<Prisma.$InsuranceContactPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more InsuranceContacts and returns the data updated in the database.
     * @param {InsuranceContactUpdateManyAndReturnArgs} args - Arguments to update many InsuranceContacts.
     * @example
     * // Update many InsuranceContacts
     * const insuranceContact = await prisma.insuranceContact.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more InsuranceContacts and only return the `id`
     * const insuranceContactWithIdOnly = await prisma.insuranceContact.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends InsuranceContactUpdateManyAndReturnArgs>(args: SelectSubset<T, InsuranceContactUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InsuranceContactPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for InsuranceContact.
   * 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__InsuranceContactClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the InsuranceContact model
   */
  interface InsuranceContactFieldRefs {
    readonly id: FieldRef<"InsuranceContact", 'Int'>
    readonly userId: FieldRef<"InsuranceContact", 'Int'>
    readonly name: FieldRef<"InsuranceContact", 'String'>
    readonly phoneNumber: FieldRef<"InsuranceContact", 'String'>
    readonly createdAt: FieldRef<"InsuranceContact", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * InsuranceContact findUnique
   */
  export type InsuranceContactFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * Filter, which InsuranceContact to fetch.
     */
    where: InsuranceContactWhereUniqueInput
  }

  /**
   * InsuranceContact findUniqueOrThrow
   */
  export type InsuranceContactFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * Filter, which InsuranceContact to fetch.
     */
    where: InsuranceContactWhereUniqueInput
  }

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

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

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

  /**
   * InsuranceContact create
   */
  export type InsuranceContactCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * The data needed to create a InsuranceContact.
     */
    data: XOR<InsuranceContactCreateInput, InsuranceContactUncheckedCreateInput>
  }

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

  /**
   * InsuranceContact createManyAndReturn
   */
  export type InsuranceContactCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * The data used to create many InsuranceContacts.
     */
    data: InsuranceContactCreateManyInput | InsuranceContactCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * InsuranceContact update
   */
  export type InsuranceContactUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * The data needed to update a InsuranceContact.
     */
    data: XOR<InsuranceContactUpdateInput, InsuranceContactUncheckedUpdateInput>
    /**
     * Choose, which InsuranceContact to update.
     */
    where: InsuranceContactWhereUniqueInput
  }

  /**
   * InsuranceContact updateMany
   */
  export type InsuranceContactUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update InsuranceContacts.
     */
    data: XOR<InsuranceContactUpdateManyMutationInput, InsuranceContactUncheckedUpdateManyInput>
    /**
     * Filter which InsuranceContacts to update
     */
    where?: InsuranceContactWhereInput
    /**
     * Limit how many InsuranceContacts to update.
     */
    limit?: number
  }

  /**
   * InsuranceContact updateManyAndReturn
   */
  export type InsuranceContactUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * The data used to update InsuranceContacts.
     */
    data: XOR<InsuranceContactUpdateManyMutationInput, InsuranceContactUncheckedUpdateManyInput>
    /**
     * Filter which InsuranceContacts to update
     */
    where?: InsuranceContactWhereInput
    /**
     * Limit how many InsuranceContacts to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * InsuranceContact upsert
   */
  export type InsuranceContactUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * The filter to search for the InsuranceContact to update in case it exists.
     */
    where: InsuranceContactWhereUniqueInput
    /**
     * In case the InsuranceContact found by the `where` argument doesn't exist, create a new InsuranceContact with this data.
     */
    create: XOR<InsuranceContactCreateInput, InsuranceContactUncheckedCreateInput>
    /**
     * In case the InsuranceContact was found with the provided `where` argument, update it with this data.
     */
    update: XOR<InsuranceContactUpdateInput, InsuranceContactUncheckedUpdateInput>
  }

  /**
   * InsuranceContact delete
   */
  export type InsuranceContactDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InsuranceContact
     */
    select?: InsuranceContactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the InsuranceContact
     */
    omit?: InsuranceContactOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: InsuranceContactInclude<ExtArgs> | null
    /**
     * Filter which InsuranceContact to delete.
     */
    where: InsuranceContactWhereUniqueInput
  }

  /**
   * InsuranceContact deleteMany
   */
  export type InsuranceContactDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InsuranceContacts to delete
     */
    where?: InsuranceContactWhereInput
    /**
     * Limit how many InsuranceContacts to delete.
     */
    limit?: number
  }

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


  /**
   * Model ProcedureTimeslot
   */

  export type AggregateProcedureTimeslot = {
    _count: ProcedureTimeslotCountAggregateOutputType | null
    _avg: ProcedureTimeslotAvgAggregateOutputType | null
    _sum: ProcedureTimeslotSumAggregateOutputType | null
    _min: ProcedureTimeslotMinAggregateOutputType | null
    _max: ProcedureTimeslotMaxAggregateOutputType | null
  }

  export type ProcedureTimeslotAvgAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ProcedureTimeslotSumAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ProcedureTimeslotMinAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ProcedureTimeslotMaxAggregateOutputType = {
    id: number | null
    userId: number | null
  }

  export type ProcedureTimeslotCountAggregateOutputType = {
    id: number
    userId: number
    data: number
    _all: number
  }


  export type ProcedureTimeslotAvgAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ProcedureTimeslotSumAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ProcedureTimeslotMinAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ProcedureTimeslotMaxAggregateInputType = {
    id?: true
    userId?: true
  }

  export type ProcedureTimeslotCountAggregateInputType = {
    id?: true
    userId?: true
    data?: true
    _all?: true
  }

  export type ProcedureTimeslotAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProcedureTimeslot to aggregate.
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProcedureTimeslots to fetch.
     */
    orderBy?: ProcedureTimeslotOrderByWithRelationInput | ProcedureTimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProcedureTimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProcedureTimeslots 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` ProcedureTimeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProcedureTimeslots
    **/
    _count?: true | ProcedureTimeslotCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProcedureTimeslotAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProcedureTimeslotSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProcedureTimeslotMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProcedureTimeslotMaxAggregateInputType
  }

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




  export type ProcedureTimeslotGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProcedureTimeslotWhereInput
    orderBy?: ProcedureTimeslotOrderByWithAggregationInput | ProcedureTimeslotOrderByWithAggregationInput[]
    by: ProcedureTimeslotScalarFieldEnum[] | ProcedureTimeslotScalarFieldEnum
    having?: ProcedureTimeslotScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProcedureTimeslotCountAggregateInputType | true
    _avg?: ProcedureTimeslotAvgAggregateInputType
    _sum?: ProcedureTimeslotSumAggregateInputType
    _min?: ProcedureTimeslotMinAggregateInputType
    _max?: ProcedureTimeslotMaxAggregateInputType
  }

  export type ProcedureTimeslotGroupByOutputType = {
    id: number
    userId: number
    data: JsonValue
    _count: ProcedureTimeslotCountAggregateOutputType | null
    _avg: ProcedureTimeslotAvgAggregateOutputType | null
    _sum: ProcedureTimeslotSumAggregateOutputType | null
    _min: ProcedureTimeslotMinAggregateOutputType | null
    _max: ProcedureTimeslotMaxAggregateOutputType | null
  }

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


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

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

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

  export type ProcedureTimeslotSelectScalar = {
    id?: boolean
    userId?: boolean
    data?: boolean
  }

  export type ProcedureTimeslotOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "data", ExtArgs["result"]["procedureTimeslot"]>
  export type ProcedureTimeslotInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ProcedureTimeslotIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ProcedureTimeslotIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ProcedureTimeslotPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProcedureTimeslot"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      userId: number
      data: Prisma.JsonValue
    }, ExtArgs["result"]["procedureTimeslot"]>
    composites: {}
  }

  type ProcedureTimeslotGetPayload<S extends boolean | null | undefined | ProcedureTimeslotDefaultArgs> = $Result.GetResult<Prisma.$ProcedureTimeslotPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProcedureTimeslot.
     * @param {ProcedureTimeslotCreateArgs} args - Arguments to create a ProcedureTimeslot.
     * @example
     * // Create one ProcedureTimeslot
     * const ProcedureTimeslot = await prisma.procedureTimeslot.create({
     *   data: {
     *     // ... data to create a ProcedureTimeslot
     *   }
     * })
     * 
     */
    create<T extends ProcedureTimeslotCreateArgs>(args: SelectSubset<T, ProcedureTimeslotCreateArgs<ExtArgs>>): Prisma__ProcedureTimeslotClient<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ProcedureTimeslots and returns the data saved in the database.
     * @param {ProcedureTimeslotCreateManyAndReturnArgs} args - Arguments to create many ProcedureTimeslots.
     * @example
     * // Create many ProcedureTimeslots
     * const procedureTimeslot = await prisma.procedureTimeslot.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ProcedureTimeslots and only return the `id`
     * const procedureTimeslotWithIdOnly = await prisma.procedureTimeslot.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 ProcedureTimeslotCreateManyAndReturnArgs>(args?: SelectSubset<T, ProcedureTimeslotCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ProcedureTimeslot.
     * @param {ProcedureTimeslotDeleteArgs} args - Arguments to delete one ProcedureTimeslot.
     * @example
     * // Delete one ProcedureTimeslot
     * const ProcedureTimeslot = await prisma.procedureTimeslot.delete({
     *   where: {
     *     // ... filter to delete one ProcedureTimeslot
     *   }
     * })
     * 
     */
    delete<T extends ProcedureTimeslotDeleteArgs>(args: SelectSubset<T, ProcedureTimeslotDeleteArgs<ExtArgs>>): Prisma__ProcedureTimeslotClient<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

    /**
     * Update zero or more ProcedureTimeslots and returns the data updated in the database.
     * @param {ProcedureTimeslotUpdateManyAndReturnArgs} args - Arguments to update many ProcedureTimeslots.
     * @example
     * // Update many ProcedureTimeslots
     * const procedureTimeslot = await prisma.procedureTimeslot.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ProcedureTimeslots and only return the `id`
     * const procedureTimeslotWithIdOnly = await prisma.procedureTimeslot.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ProcedureTimeslotUpdateManyAndReturnArgs>(args: SelectSubset<T, ProcedureTimeslotUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one ProcedureTimeslot.
     * @param {ProcedureTimeslotUpsertArgs} args - Arguments to update or create a ProcedureTimeslot.
     * @example
     * // Update or create a ProcedureTimeslot
     * const procedureTimeslot = await prisma.procedureTimeslot.upsert({
     *   create: {
     *     // ... data to create a ProcedureTimeslot
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the ProcedureTimeslot we want to update
     *   }
     * })
     */
    upsert<T extends ProcedureTimeslotUpsertArgs>(args: SelectSubset<T, ProcedureTimeslotUpsertArgs<ExtArgs>>): Prisma__ProcedureTimeslotClient<$Result.GetResult<Prisma.$ProcedureTimeslotPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of ProcedureTimeslots.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProcedureTimeslotCountArgs} args - Arguments to filter ProcedureTimeslots to count.
     * @example
     * // Count the number of ProcedureTimeslots
     * const count = await prisma.procedureTimeslot.count({
     *   where: {
     *     // ... the filter for the ProcedureTimeslots we want to count
     *   }
     * })
    **/
    count<T extends ProcedureTimeslotCountArgs>(
      args?: Subset<T, ProcedureTimeslotCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ProcedureTimeslotCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a ProcedureTimeslot.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProcedureTimeslotAggregateArgs} 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 ProcedureTimeslotAggregateArgs>(args: Subset<T, ProcedureTimeslotAggregateArgs>): Prisma.PrismaPromise<GetProcedureTimeslotAggregateType<T>>

    /**
     * Group by ProcedureTimeslot.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProcedureTimeslotGroupByArgs} 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 ProcedureTimeslotGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ProcedureTimeslotGroupByArgs['orderBy'] }
        : { orderBy?: ProcedureTimeslotGroupByArgs['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, ProcedureTimeslotGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProcedureTimeslotGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ProcedureTimeslot model
   */
  readonly fields: ProcedureTimeslotFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ProcedureTimeslot.
   * 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__ProcedureTimeslotClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ProcedureTimeslot model
   */
  interface ProcedureTimeslotFieldRefs {
    readonly id: FieldRef<"ProcedureTimeslot", 'Int'>
    readonly userId: FieldRef<"ProcedureTimeslot", 'Int'>
    readonly data: FieldRef<"ProcedureTimeslot", 'Json'>
  }
    

  // Custom InputTypes
  /**
   * ProcedureTimeslot findUnique
   */
  export type ProcedureTimeslotFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter, which ProcedureTimeslot to fetch.
     */
    where: ProcedureTimeslotWhereUniqueInput
  }

  /**
   * ProcedureTimeslot findUniqueOrThrow
   */
  export type ProcedureTimeslotFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter, which ProcedureTimeslot to fetch.
     */
    where: ProcedureTimeslotWhereUniqueInput
  }

  /**
   * ProcedureTimeslot findFirst
   */
  export type ProcedureTimeslotFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter, which ProcedureTimeslot to fetch.
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProcedureTimeslots to fetch.
     */
    orderBy?: ProcedureTimeslotOrderByWithRelationInput | ProcedureTimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ProcedureTimeslots.
     */
    cursor?: ProcedureTimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProcedureTimeslots 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` ProcedureTimeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ProcedureTimeslots.
     */
    distinct?: ProcedureTimeslotScalarFieldEnum | ProcedureTimeslotScalarFieldEnum[]
  }

  /**
   * ProcedureTimeslot findFirstOrThrow
   */
  export type ProcedureTimeslotFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter, which ProcedureTimeslot to fetch.
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProcedureTimeslots to fetch.
     */
    orderBy?: ProcedureTimeslotOrderByWithRelationInput | ProcedureTimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ProcedureTimeslots.
     */
    cursor?: ProcedureTimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProcedureTimeslots 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` ProcedureTimeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ProcedureTimeslots.
     */
    distinct?: ProcedureTimeslotScalarFieldEnum | ProcedureTimeslotScalarFieldEnum[]
  }

  /**
   * ProcedureTimeslot findMany
   */
  export type ProcedureTimeslotFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter, which ProcedureTimeslots to fetch.
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProcedureTimeslots to fetch.
     */
    orderBy?: ProcedureTimeslotOrderByWithRelationInput | ProcedureTimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ProcedureTimeslots.
     */
    cursor?: ProcedureTimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProcedureTimeslots 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` ProcedureTimeslots.
     */
    skip?: number
    distinct?: ProcedureTimeslotScalarFieldEnum | ProcedureTimeslotScalarFieldEnum[]
  }

  /**
   * ProcedureTimeslot create
   */
  export type ProcedureTimeslotCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * The data needed to create a ProcedureTimeslot.
     */
    data: XOR<ProcedureTimeslotCreateInput, ProcedureTimeslotUncheckedCreateInput>
  }

  /**
   * ProcedureTimeslot createMany
   */
  export type ProcedureTimeslotCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ProcedureTimeslots.
     */
    data: ProcedureTimeslotCreateManyInput | ProcedureTimeslotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ProcedureTimeslot createManyAndReturn
   */
  export type ProcedureTimeslotCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * The data used to create many ProcedureTimeslots.
     */
    data: ProcedureTimeslotCreateManyInput | ProcedureTimeslotCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ProcedureTimeslot update
   */
  export type ProcedureTimeslotUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * The data needed to update a ProcedureTimeslot.
     */
    data: XOR<ProcedureTimeslotUpdateInput, ProcedureTimeslotUncheckedUpdateInput>
    /**
     * Choose, which ProcedureTimeslot to update.
     */
    where: ProcedureTimeslotWhereUniqueInput
  }

  /**
   * ProcedureTimeslot updateMany
   */
  export type ProcedureTimeslotUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProcedureTimeslots.
     */
    data: XOR<ProcedureTimeslotUpdateManyMutationInput, ProcedureTimeslotUncheckedUpdateManyInput>
    /**
     * Filter which ProcedureTimeslots to update
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * Limit how many ProcedureTimeslots to update.
     */
    limit?: number
  }

  /**
   * ProcedureTimeslot updateManyAndReturn
   */
  export type ProcedureTimeslotUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * The data used to update ProcedureTimeslots.
     */
    data: XOR<ProcedureTimeslotUpdateManyMutationInput, ProcedureTimeslotUncheckedUpdateManyInput>
    /**
     * Filter which ProcedureTimeslots to update
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * Limit how many ProcedureTimeslots to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ProcedureTimeslot upsert
   */
  export type ProcedureTimeslotUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * The filter to search for the ProcedureTimeslot to update in case it exists.
     */
    where: ProcedureTimeslotWhereUniqueInput
    /**
     * In case the ProcedureTimeslot found by the `where` argument doesn't exist, create a new ProcedureTimeslot with this data.
     */
    create: XOR<ProcedureTimeslotCreateInput, ProcedureTimeslotUncheckedCreateInput>
    /**
     * In case the ProcedureTimeslot was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProcedureTimeslotUpdateInput, ProcedureTimeslotUncheckedUpdateInput>
  }

  /**
   * ProcedureTimeslot delete
   */
  export type ProcedureTimeslotDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
    /**
     * Filter which ProcedureTimeslot to delete.
     */
    where: ProcedureTimeslotWhereUniqueInput
  }

  /**
   * ProcedureTimeslot deleteMany
   */
  export type ProcedureTimeslotDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProcedureTimeslots to delete
     */
    where?: ProcedureTimeslotWhereInput
    /**
     * Limit how many ProcedureTimeslots to delete.
     */
    limit?: number
  }

  /**
   * ProcedureTimeslot without action
   */
  export type ProcedureTimeslotDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProcedureTimeslot
     */
    select?: ProcedureTimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ProcedureTimeslot
     */
    omit?: ProcedureTimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProcedureTimeslotInclude<ExtArgs> | null
  }


  /**
   * Model PatientConversation
   */

  export type AggregatePatientConversation = {
    _count: PatientConversationCountAggregateOutputType | null
    _avg: PatientConversationAvgAggregateOutputType | null
    _sum: PatientConversationSumAggregateOutputType | null
    _min: PatientConversationMinAggregateOutputType | null
    _max: PatientConversationMaxAggregateOutputType | null
  }

  export type PatientConversationAvgAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
  }

  export type PatientConversationSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
  }

  export type PatientConversationMinAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    stage: string | null
    aiHandoff: boolean | null
    updatedAt: Date | null
  }

  export type PatientConversationMaxAggregateOutputType = {
    id: number | null
    patientId: number | null
    userId: number | null
    stage: string | null
    aiHandoff: boolean | null
    updatedAt: Date | null
  }

  export type PatientConversationCountAggregateOutputType = {
    id: number
    patientId: number
    userId: number
    stage: number
    aiHandoff: number
    updatedAt: number
    _all: number
  }


  export type PatientConversationAvgAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
  }

  export type PatientConversationSumAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
  }

  export type PatientConversationMinAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    stage?: true
    aiHandoff?: true
    updatedAt?: true
  }

  export type PatientConversationMaxAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    stage?: true
    aiHandoff?: true
    updatedAt?: true
  }

  export type PatientConversationCountAggregateInputType = {
    id?: true
    patientId?: true
    userId?: true
    stage?: true
    aiHandoff?: true
    updatedAt?: true
    _all?: true
  }

  export type PatientConversationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PatientConversation to aggregate.
     */
    where?: PatientConversationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PatientConversations to fetch.
     */
    orderBy?: PatientConversationOrderByWithRelationInput | PatientConversationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PatientConversationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PatientConversations 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` PatientConversations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PatientConversations
    **/
    _count?: true | PatientConversationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PatientConversationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PatientConversationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PatientConversationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PatientConversationMaxAggregateInputType
  }

  export type GetPatientConversationAggregateType<T extends PatientConversationAggregateArgs> = {
        [P in keyof T & keyof AggregatePatientConversation]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePatientConversation[P]>
      : GetScalarType<T[P], AggregatePatientConversation[P]>
  }




  export type PatientConversationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PatientConversationWhereInput
    orderBy?: PatientConversationOrderByWithAggregationInput | PatientConversationOrderByWithAggregationInput[]
    by: PatientConversationScalarFieldEnum[] | PatientConversationScalarFieldEnum
    having?: PatientConversationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PatientConversationCountAggregateInputType | true
    _avg?: PatientConversationAvgAggregateInputType
    _sum?: PatientConversationSumAggregateInputType
    _min?: PatientConversationMinAggregateInputType
    _max?: PatientConversationMaxAggregateInputType
  }

  export type PatientConversationGroupByOutputType = {
    id: number
    patientId: number
    userId: number
    stage: string
    aiHandoff: boolean
    updatedAt: Date
    _count: PatientConversationCountAggregateOutputType | null
    _avg: PatientConversationAvgAggregateOutputType | null
    _sum: PatientConversationSumAggregateOutputType | null
    _min: PatientConversationMinAggregateOutputType | null
    _max: PatientConversationMaxAggregateOutputType | null
  }

  type GetPatientConversationGroupByPayload<T extends PatientConversationGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PatientConversationGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PatientConversationGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PatientConversationGroupByOutputType[P]>
            : GetScalarType<T[P], PatientConversationGroupByOutputType[P]>
        }
      >
    >


  export type PatientConversationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    stage?: boolean
    aiHandoff?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientConversation"]>

  export type PatientConversationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    stage?: boolean
    aiHandoff?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientConversation"]>

  export type PatientConversationSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    patientId?: boolean
    userId?: boolean
    stage?: boolean
    aiHandoff?: boolean
    updatedAt?: boolean
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patientConversation"]>

  export type PatientConversationSelectScalar = {
    id?: boolean
    patientId?: boolean
    userId?: boolean
    stage?: boolean
    aiHandoff?: boolean
    updatedAt?: boolean
  }

  export type PatientConversationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "patientId" | "userId" | "stage" | "aiHandoff" | "updatedAt", ExtArgs["result"]["patientConversation"]>
  export type PatientConversationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type PatientConversationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type PatientConversationIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $PatientConversationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PatientConversation"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      userId: number
      stage: string
      aiHandoff: boolean
      updatedAt: Date
    }, ExtArgs["result"]["patientConversation"]>
    composites: {}
  }

  type PatientConversationGetPayload<S extends boolean | null | undefined | PatientConversationDefaultArgs> = $Result.GetResult<Prisma.$PatientConversationPayload, S>

  type PatientConversationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PatientConversationFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PatientConversationCountAggregateInputType | true
    }

  export interface PatientConversationDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['PatientConversation'], meta: { name: 'PatientConversation' } }
    /**
     * Find zero or one PatientConversation that matches the filter.
     * @param {PatientConversationFindUniqueArgs} args - Arguments to find a PatientConversation
     * @example
     * // Get one PatientConversation
     * const patientConversation = await prisma.patientConversation.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PatientConversationFindUniqueArgs>(args: SelectSubset<T, PatientConversationFindUniqueArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one PatientConversation that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PatientConversationFindUniqueOrThrowArgs} args - Arguments to find a PatientConversation
     * @example
     * // Get one PatientConversation
     * const patientConversation = await prisma.patientConversation.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PatientConversationFindUniqueOrThrowArgs>(args: SelectSubset<T, PatientConversationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PatientConversation 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 {PatientConversationFindFirstArgs} args - Arguments to find a PatientConversation
     * @example
     * // Get one PatientConversation
     * const patientConversation = await prisma.patientConversation.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PatientConversationFindFirstArgs>(args?: SelectSubset<T, PatientConversationFindFirstArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PatientConversation 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 {PatientConversationFindFirstOrThrowArgs} args - Arguments to find a PatientConversation
     * @example
     * // Get one PatientConversation
     * const patientConversation = await prisma.patientConversation.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PatientConversationFindFirstOrThrowArgs>(args?: SelectSubset<T, PatientConversationFindFirstOrThrowArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more PatientConversations 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 {PatientConversationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all PatientConversations
     * const patientConversations = await prisma.patientConversation.findMany()
     * 
     * // Get first 10 PatientConversations
     * const patientConversations = await prisma.patientConversation.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const patientConversationWithIdOnly = await prisma.patientConversation.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PatientConversationFindManyArgs>(args?: SelectSubset<T, PatientConversationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a PatientConversation.
     * @param {PatientConversationCreateArgs} args - Arguments to create a PatientConversation.
     * @example
     * // Create one PatientConversation
     * const PatientConversation = await prisma.patientConversation.create({
     *   data: {
     *     // ... data to create a PatientConversation
     *   }
     * })
     * 
     */
    create<T extends PatientConversationCreateArgs>(args: SelectSubset<T, PatientConversationCreateArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many PatientConversations.
     * @param {PatientConversationCreateManyArgs} args - Arguments to create many PatientConversations.
     * @example
     * // Create many PatientConversations
     * const patientConversation = await prisma.patientConversation.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PatientConversationCreateManyArgs>(args?: SelectSubset<T, PatientConversationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many PatientConversations and returns the data saved in the database.
     * @param {PatientConversationCreateManyAndReturnArgs} args - Arguments to create many PatientConversations.
     * @example
     * // Create many PatientConversations
     * const patientConversation = await prisma.patientConversation.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many PatientConversations and only return the `id`
     * const patientConversationWithIdOnly = await prisma.patientConversation.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 PatientConversationCreateManyAndReturnArgs>(args?: SelectSubset<T, PatientConversationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a PatientConversation.
     * @param {PatientConversationDeleteArgs} args - Arguments to delete one PatientConversation.
     * @example
     * // Delete one PatientConversation
     * const PatientConversation = await prisma.patientConversation.delete({
     *   where: {
     *     // ... filter to delete one PatientConversation
     *   }
     * })
     * 
     */
    delete<T extends PatientConversationDeleteArgs>(args: SelectSubset<T, PatientConversationDeleteArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one PatientConversation.
     * @param {PatientConversationUpdateArgs} args - Arguments to update one PatientConversation.
     * @example
     * // Update one PatientConversation
     * const patientConversation = await prisma.patientConversation.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PatientConversationUpdateArgs>(args: SelectSubset<T, PatientConversationUpdateArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more PatientConversations.
     * @param {PatientConversationDeleteManyArgs} args - Arguments to filter PatientConversations to delete.
     * @example
     * // Delete a few PatientConversations
     * const { count } = await prisma.patientConversation.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PatientConversationDeleteManyArgs>(args?: SelectSubset<T, PatientConversationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PatientConversations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PatientConversationUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many PatientConversations
     * const patientConversation = await prisma.patientConversation.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PatientConversationUpdateManyArgs>(args: SelectSubset<T, PatientConversationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PatientConversations and returns the data updated in the database.
     * @param {PatientConversationUpdateManyAndReturnArgs} args - Arguments to update many PatientConversations.
     * @example
     * // Update many PatientConversations
     * const patientConversation = await prisma.patientConversation.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more PatientConversations and only return the `id`
     * const patientConversationWithIdOnly = await prisma.patientConversation.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PatientConversationUpdateManyAndReturnArgs>(args: SelectSubset<T, PatientConversationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one PatientConversation.
     * @param {PatientConversationUpsertArgs} args - Arguments to update or create a PatientConversation.
     * @example
     * // Update or create a PatientConversation
     * const patientConversation = await prisma.patientConversation.upsert({
     *   create: {
     *     // ... data to create a PatientConversation
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the PatientConversation we want to update
     *   }
     * })
     */
    upsert<T extends PatientConversationUpsertArgs>(args: SelectSubset<T, PatientConversationUpsertArgs<ExtArgs>>): Prisma__PatientConversationClient<$Result.GetResult<Prisma.$PatientConversationPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of PatientConversations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PatientConversationCountArgs} args - Arguments to filter PatientConversations to count.
     * @example
     * // Count the number of PatientConversations
     * const count = await prisma.patientConversation.count({
     *   where: {
     *     // ... the filter for the PatientConversations we want to count
     *   }
     * })
    **/
    count<T extends PatientConversationCountArgs>(
      args?: Subset<T, PatientConversationCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PatientConversationCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a PatientConversation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PatientConversationAggregateArgs} 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 PatientConversationAggregateArgs>(args: Subset<T, PatientConversationAggregateArgs>): Prisma.PrismaPromise<GetPatientConversationAggregateType<T>>

    /**
     * Group by PatientConversation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PatientConversationGroupByArgs} 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 PatientConversationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PatientConversationGroupByArgs['orderBy'] }
        : { orderBy?: PatientConversationGroupByArgs['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, PatientConversationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPatientConversationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the PatientConversation model
   */
  readonly fields: PatientConversationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for PatientConversation.
   * 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__PatientConversationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patient<T extends PatientDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PatientDefaultArgs<ExtArgs>>): Prisma__PatientClient<$Result.GetResult<Prisma.$PatientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PatientConversation model
   */
  interface PatientConversationFieldRefs {
    readonly id: FieldRef<"PatientConversation", 'Int'>
    readonly patientId: FieldRef<"PatientConversation", 'Int'>
    readonly userId: FieldRef<"PatientConversation", 'Int'>
    readonly stage: FieldRef<"PatientConversation", 'String'>
    readonly aiHandoff: FieldRef<"PatientConversation", 'Boolean'>
    readonly updatedAt: FieldRef<"PatientConversation", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * PatientConversation findUnique
   */
  export type PatientConversationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter, which PatientConversation to fetch.
     */
    where: PatientConversationWhereUniqueInput
  }

  /**
   * PatientConversation findUniqueOrThrow
   */
  export type PatientConversationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter, which PatientConversation to fetch.
     */
    where: PatientConversationWhereUniqueInput
  }

  /**
   * PatientConversation findFirst
   */
  export type PatientConversationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter, which PatientConversation to fetch.
     */
    where?: PatientConversationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PatientConversations to fetch.
     */
    orderBy?: PatientConversationOrderByWithRelationInput | PatientConversationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PatientConversations.
     */
    cursor?: PatientConversationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PatientConversations 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` PatientConversations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PatientConversations.
     */
    distinct?: PatientConversationScalarFieldEnum | PatientConversationScalarFieldEnum[]
  }

  /**
   * PatientConversation findFirstOrThrow
   */
  export type PatientConversationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter, which PatientConversation to fetch.
     */
    where?: PatientConversationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PatientConversations to fetch.
     */
    orderBy?: PatientConversationOrderByWithRelationInput | PatientConversationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PatientConversations.
     */
    cursor?: PatientConversationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PatientConversations 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` PatientConversations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PatientConversations.
     */
    distinct?: PatientConversationScalarFieldEnum | PatientConversationScalarFieldEnum[]
  }

  /**
   * PatientConversation findMany
   */
  export type PatientConversationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter, which PatientConversations to fetch.
     */
    where?: PatientConversationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PatientConversations to fetch.
     */
    orderBy?: PatientConversationOrderByWithRelationInput | PatientConversationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PatientConversations.
     */
    cursor?: PatientConversationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PatientConversations 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` PatientConversations.
     */
    skip?: number
    distinct?: PatientConversationScalarFieldEnum | PatientConversationScalarFieldEnum[]
  }

  /**
   * PatientConversation create
   */
  export type PatientConversationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * The data needed to create a PatientConversation.
     */
    data: XOR<PatientConversationCreateInput, PatientConversationUncheckedCreateInput>
  }

  /**
   * PatientConversation createMany
   */
  export type PatientConversationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PatientConversations.
     */
    data: PatientConversationCreateManyInput | PatientConversationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * PatientConversation createManyAndReturn
   */
  export type PatientConversationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * The data used to create many PatientConversations.
     */
    data: PatientConversationCreateManyInput | PatientConversationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PatientConversation update
   */
  export type PatientConversationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * The data needed to update a PatientConversation.
     */
    data: XOR<PatientConversationUpdateInput, PatientConversationUncheckedUpdateInput>
    /**
     * Choose, which PatientConversation to update.
     */
    where: PatientConversationWhereUniqueInput
  }

  /**
   * PatientConversation updateMany
   */
  export type PatientConversationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PatientConversations.
     */
    data: XOR<PatientConversationUpdateManyMutationInput, PatientConversationUncheckedUpdateManyInput>
    /**
     * Filter which PatientConversations to update
     */
    where?: PatientConversationWhereInput
    /**
     * Limit how many PatientConversations to update.
     */
    limit?: number
  }

  /**
   * PatientConversation updateManyAndReturn
   */
  export type PatientConversationUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * The data used to update PatientConversations.
     */
    data: XOR<PatientConversationUpdateManyMutationInput, PatientConversationUncheckedUpdateManyInput>
    /**
     * Filter which PatientConversations to update
     */
    where?: PatientConversationWhereInput
    /**
     * Limit how many PatientConversations to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * PatientConversation upsert
   */
  export type PatientConversationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * The filter to search for the PatientConversation to update in case it exists.
     */
    where: PatientConversationWhereUniqueInput
    /**
     * In case the PatientConversation found by the `where` argument doesn't exist, create a new PatientConversation with this data.
     */
    create: XOR<PatientConversationCreateInput, PatientConversationUncheckedCreateInput>
    /**
     * In case the PatientConversation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PatientConversationUpdateInput, PatientConversationUncheckedUpdateInput>
  }

  /**
   * PatientConversation delete
   */
  export type PatientConversationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
    /**
     * Filter which PatientConversation to delete.
     */
    where: PatientConversationWhereUniqueInput
  }

  /**
   * PatientConversation deleteMany
   */
  export type PatientConversationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PatientConversations to delete
     */
    where?: PatientConversationWhereInput
    /**
     * Limit how many PatientConversations to delete.
     */
    limit?: number
  }

  /**
   * PatientConversation without action
   */
  export type PatientConversationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PatientConversation
     */
    select?: PatientConversationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PatientConversation
     */
    omit?: PatientConversationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PatientConversationInclude<ExtArgs> | null
  }


  /**
   * Model CommissionBatch
   */

  export type AggregateCommissionBatch = {
    _count: CommissionBatchCountAggregateOutputType | null
    _avg: CommissionBatchAvgAggregateOutputType | null
    _sum: CommissionBatchSumAggregateOutputType | null
    _min: CommissionBatchMinAggregateOutputType | null
    _max: CommissionBatchMaxAggregateOutputType | null
  }

  export type CommissionBatchAvgAggregateOutputType = {
    id: number | null
    npiProviderId: number | null
    totalCollection: Decimal | null
    commissionAmount: Decimal | null
  }

  export type CommissionBatchSumAggregateOutputType = {
    id: number | null
    npiProviderId: number | null
    totalCollection: Decimal | null
    commissionAmount: Decimal | null
  }

  export type CommissionBatchMinAggregateOutputType = {
    id: number | null
    npiProviderId: number | null
    totalCollection: Decimal | null
    commissionAmount: Decimal | null
    notes: string | null
    createdAt: Date | null
  }

  export type CommissionBatchMaxAggregateOutputType = {
    id: number | null
    npiProviderId: number | null
    totalCollection: Decimal | null
    commissionAmount: Decimal | null
    notes: string | null
    createdAt: Date | null
  }

  export type CommissionBatchCountAggregateOutputType = {
    id: number
    npiProviderId: number
    totalCollection: number
    commissionAmount: number
    notes: number
    createdAt: number
    _all: number
  }


  export type CommissionBatchAvgAggregateInputType = {
    id?: true
    npiProviderId?: true
    totalCollection?: true
    commissionAmount?: true
  }

  export type CommissionBatchSumAggregateInputType = {
    id?: true
    npiProviderId?: true
    totalCollection?: true
    commissionAmount?: true
  }

  export type CommissionBatchMinAggregateInputType = {
    id?: true
    npiProviderId?: true
    totalCollection?: true
    commissionAmount?: true
    notes?: true
    createdAt?: true
  }

  export type CommissionBatchMaxAggregateInputType = {
    id?: true
    npiProviderId?: true
    totalCollection?: true
    commissionAmount?: true
    notes?: true
    createdAt?: true
  }

  export type CommissionBatchCountAggregateInputType = {
    id?: true
    npiProviderId?: true
    totalCollection?: true
    commissionAmount?: true
    notes?: true
    createdAt?: true
    _all?: true
  }

  export type CommissionBatchAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommissionBatch to aggregate.
     */
    where?: CommissionBatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatches to fetch.
     */
    orderBy?: CommissionBatchOrderByWithRelationInput | CommissionBatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CommissionBatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatches 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` CommissionBatches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CommissionBatches
    **/
    _count?: true | CommissionBatchCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CommissionBatchAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CommissionBatchSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CommissionBatchMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CommissionBatchMaxAggregateInputType
  }

  export type GetCommissionBatchAggregateType<T extends CommissionBatchAggregateArgs> = {
        [P in keyof T & keyof AggregateCommissionBatch]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCommissionBatch[P]>
      : GetScalarType<T[P], AggregateCommissionBatch[P]>
  }




  export type CommissionBatchGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionBatchWhereInput
    orderBy?: CommissionBatchOrderByWithAggregationInput | CommissionBatchOrderByWithAggregationInput[]
    by: CommissionBatchScalarFieldEnum[] | CommissionBatchScalarFieldEnum
    having?: CommissionBatchScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommissionBatchCountAggregateInputType | true
    _avg?: CommissionBatchAvgAggregateInputType
    _sum?: CommissionBatchSumAggregateInputType
    _min?: CommissionBatchMinAggregateInputType
    _max?: CommissionBatchMaxAggregateInputType
  }

  export type CommissionBatchGroupByOutputType = {
    id: number
    npiProviderId: number
    totalCollection: Decimal
    commissionAmount: Decimal
    notes: string | null
    createdAt: Date
    _count: CommissionBatchCountAggregateOutputType | null
    _avg: CommissionBatchAvgAggregateOutputType | null
    _sum: CommissionBatchSumAggregateOutputType | null
    _min: CommissionBatchMinAggregateOutputType | null
    _max: CommissionBatchMaxAggregateOutputType | null
  }

  type GetCommissionBatchGroupByPayload<T extends CommissionBatchGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CommissionBatchGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CommissionBatchGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CommissionBatchGroupByOutputType[P]>
            : GetScalarType<T[P], CommissionBatchGroupByOutputType[P]>
        }
      >
    >


  export type CommissionBatchSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    npiProviderId?: boolean
    totalCollection?: boolean
    commissionAmount?: boolean
    notes?: boolean
    createdAt?: boolean
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
    items?: boolean | CommissionBatch$itemsArgs<ExtArgs>
    _count?: boolean | CommissionBatchCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatch"]>

  export type CommissionBatchSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    npiProviderId?: boolean
    totalCollection?: boolean
    commissionAmount?: boolean
    notes?: boolean
    createdAt?: boolean
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatch"]>

  export type CommissionBatchSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    npiProviderId?: boolean
    totalCollection?: boolean
    commissionAmount?: boolean
    notes?: boolean
    createdAt?: boolean
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatch"]>

  export type CommissionBatchSelectScalar = {
    id?: boolean
    npiProviderId?: boolean
    totalCollection?: boolean
    commissionAmount?: boolean
    notes?: boolean
    createdAt?: boolean
  }

  export type CommissionBatchOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "npiProviderId" | "totalCollection" | "commissionAmount" | "notes" | "createdAt", ExtArgs["result"]["commissionBatch"]>
  export type CommissionBatchInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
    items?: boolean | CommissionBatch$itemsArgs<ExtArgs>
    _count?: boolean | CommissionBatchCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CommissionBatchIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
  }
  export type CommissionBatchIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    npiProvider?: boolean | NpiProviderDefaultArgs<ExtArgs>
  }

  export type $CommissionBatchPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CommissionBatch"
    objects: {
      npiProvider: Prisma.$NpiProviderPayload<ExtArgs>
      items: Prisma.$CommissionBatchItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      npiProviderId: number
      totalCollection: Prisma.Decimal
      commissionAmount: Prisma.Decimal
      notes: string | null
      createdAt: Date
    }, ExtArgs["result"]["commissionBatch"]>
    composites: {}
  }

  type CommissionBatchGetPayload<S extends boolean | null | undefined | CommissionBatchDefaultArgs> = $Result.GetResult<Prisma.$CommissionBatchPayload, S>

  type CommissionBatchCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<CommissionBatchFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: CommissionBatchCountAggregateInputType | true
    }

  export interface CommissionBatchDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['CommissionBatch'], meta: { name: 'CommissionBatch' } }
    /**
     * Find zero or one CommissionBatch that matches the filter.
     * @param {CommissionBatchFindUniqueArgs} args - Arguments to find a CommissionBatch
     * @example
     * // Get one CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends CommissionBatchFindUniqueArgs>(args: SelectSubset<T, CommissionBatchFindUniqueArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one CommissionBatch that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {CommissionBatchFindUniqueOrThrowArgs} args - Arguments to find a CommissionBatch
     * @example
     * // Get one CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends CommissionBatchFindUniqueOrThrowArgs>(args: SelectSubset<T, CommissionBatchFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first CommissionBatch 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 {CommissionBatchFindFirstArgs} args - Arguments to find a CommissionBatch
     * @example
     * // Get one CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends CommissionBatchFindFirstArgs>(args?: SelectSubset<T, CommissionBatchFindFirstArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first CommissionBatch 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 {CommissionBatchFindFirstOrThrowArgs} args - Arguments to find a CommissionBatch
     * @example
     * // Get one CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends CommissionBatchFindFirstOrThrowArgs>(args?: SelectSubset<T, CommissionBatchFindFirstOrThrowArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more CommissionBatches 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 {CommissionBatchFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all CommissionBatches
     * const commissionBatches = await prisma.commissionBatch.findMany()
     * 
     * // Get first 10 CommissionBatches
     * const commissionBatches = await prisma.commissionBatch.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const commissionBatchWithIdOnly = await prisma.commissionBatch.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends CommissionBatchFindManyArgs>(args?: SelectSubset<T, CommissionBatchFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a CommissionBatch.
     * @param {CommissionBatchCreateArgs} args - Arguments to create a CommissionBatch.
     * @example
     * // Create one CommissionBatch
     * const CommissionBatch = await prisma.commissionBatch.create({
     *   data: {
     *     // ... data to create a CommissionBatch
     *   }
     * })
     * 
     */
    create<T extends CommissionBatchCreateArgs>(args: SelectSubset<T, CommissionBatchCreateArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many CommissionBatches.
     * @param {CommissionBatchCreateManyArgs} args - Arguments to create many CommissionBatches.
     * @example
     * // Create many CommissionBatches
     * const commissionBatch = await prisma.commissionBatch.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends CommissionBatchCreateManyArgs>(args?: SelectSubset<T, CommissionBatchCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many CommissionBatches and returns the data saved in the database.
     * @param {CommissionBatchCreateManyAndReturnArgs} args - Arguments to create many CommissionBatches.
     * @example
     * // Create many CommissionBatches
     * const commissionBatch = await prisma.commissionBatch.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CommissionBatches and only return the `id`
     * const commissionBatchWithIdOnly = await prisma.commissionBatch.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 CommissionBatchCreateManyAndReturnArgs>(args?: SelectSubset<T, CommissionBatchCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CommissionBatch.
     * @param {CommissionBatchDeleteArgs} args - Arguments to delete one CommissionBatch.
     * @example
     * // Delete one CommissionBatch
     * const CommissionBatch = await prisma.commissionBatch.delete({
     *   where: {
     *     // ... filter to delete one CommissionBatch
     *   }
     * })
     * 
     */
    delete<T extends CommissionBatchDeleteArgs>(args: SelectSubset<T, CommissionBatchDeleteArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one CommissionBatch.
     * @param {CommissionBatchUpdateArgs} args - Arguments to update one CommissionBatch.
     * @example
     * // Update one CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CommissionBatchUpdateArgs>(args: SelectSubset<T, CommissionBatchUpdateArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more CommissionBatches.
     * @param {CommissionBatchDeleteManyArgs} args - Arguments to filter CommissionBatches to delete.
     * @example
     * // Delete a few CommissionBatches
     * const { count } = await prisma.commissionBatch.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends CommissionBatchDeleteManyArgs>(args?: SelectSubset<T, CommissionBatchDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CommissionBatches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many CommissionBatches
     * const commissionBatch = await prisma.commissionBatch.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends CommissionBatchUpdateManyArgs>(args: SelectSubset<T, CommissionBatchUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CommissionBatches and returns the data updated in the database.
     * @param {CommissionBatchUpdateManyAndReturnArgs} args - Arguments to update many CommissionBatches.
     * @example
     * // Update many CommissionBatches
     * const commissionBatch = await prisma.commissionBatch.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CommissionBatches and only return the `id`
     * const commissionBatchWithIdOnly = await prisma.commissionBatch.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CommissionBatchUpdateManyAndReturnArgs>(args: SelectSubset<T, CommissionBatchUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one CommissionBatch.
     * @param {CommissionBatchUpsertArgs} args - Arguments to update or create a CommissionBatch.
     * @example
     * // Update or create a CommissionBatch
     * const commissionBatch = await prisma.commissionBatch.upsert({
     *   create: {
     *     // ... data to create a CommissionBatch
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the CommissionBatch we want to update
     *   }
     * })
     */
    upsert<T extends CommissionBatchUpsertArgs>(args: SelectSubset<T, CommissionBatchUpsertArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of CommissionBatches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchCountArgs} args - Arguments to filter CommissionBatches to count.
     * @example
     * // Count the number of CommissionBatches
     * const count = await prisma.commissionBatch.count({
     *   where: {
     *     // ... the filter for the CommissionBatches we want to count
     *   }
     * })
    **/
    count<T extends CommissionBatchCountArgs>(
      args?: Subset<T, CommissionBatchCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CommissionBatchCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a CommissionBatch.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchAggregateArgs} 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 CommissionBatchAggregateArgs>(args: Subset<T, CommissionBatchAggregateArgs>): Prisma.PrismaPromise<GetCommissionBatchAggregateType<T>>

    /**
     * Group by CommissionBatch.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchGroupByArgs} 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 CommissionBatchGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CommissionBatchGroupByArgs['orderBy'] }
        : { orderBy?: CommissionBatchGroupByArgs['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, CommissionBatchGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCommissionBatchGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the CommissionBatch model
   */
  readonly fields: CommissionBatchFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for CommissionBatch.
   * 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__CommissionBatchClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    npiProvider<T extends NpiProviderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, NpiProviderDefaultArgs<ExtArgs>>): Prisma__NpiProviderClient<$Result.GetResult<Prisma.$NpiProviderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    items<T extends CommissionBatch$itemsArgs<ExtArgs> = {}>(args?: Subset<T, CommissionBatch$itemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CommissionBatch model
   */
  interface CommissionBatchFieldRefs {
    readonly id: FieldRef<"CommissionBatch", 'Int'>
    readonly npiProviderId: FieldRef<"CommissionBatch", 'Int'>
    readonly totalCollection: FieldRef<"CommissionBatch", 'Decimal'>
    readonly commissionAmount: FieldRef<"CommissionBatch", 'Decimal'>
    readonly notes: FieldRef<"CommissionBatch", 'String'>
    readonly createdAt: FieldRef<"CommissionBatch", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CommissionBatch findUnique
   */
  export type CommissionBatchFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatch to fetch.
     */
    where: CommissionBatchWhereUniqueInput
  }

  /**
   * CommissionBatch findUniqueOrThrow
   */
  export type CommissionBatchFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatch to fetch.
     */
    where: CommissionBatchWhereUniqueInput
  }

  /**
   * CommissionBatch findFirst
   */
  export type CommissionBatchFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatch to fetch.
     */
    where?: CommissionBatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatches to fetch.
     */
    orderBy?: CommissionBatchOrderByWithRelationInput | CommissionBatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CommissionBatches.
     */
    cursor?: CommissionBatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatches 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` CommissionBatches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CommissionBatches.
     */
    distinct?: CommissionBatchScalarFieldEnum | CommissionBatchScalarFieldEnum[]
  }

  /**
   * CommissionBatch findFirstOrThrow
   */
  export type CommissionBatchFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatch to fetch.
     */
    where?: CommissionBatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatches to fetch.
     */
    orderBy?: CommissionBatchOrderByWithRelationInput | CommissionBatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CommissionBatches.
     */
    cursor?: CommissionBatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatches 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` CommissionBatches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CommissionBatches.
     */
    distinct?: CommissionBatchScalarFieldEnum | CommissionBatchScalarFieldEnum[]
  }

  /**
   * CommissionBatch findMany
   */
  export type CommissionBatchFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatches to fetch.
     */
    where?: CommissionBatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatches to fetch.
     */
    orderBy?: CommissionBatchOrderByWithRelationInput | CommissionBatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CommissionBatches.
     */
    cursor?: CommissionBatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatches 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` CommissionBatches.
     */
    skip?: number
    distinct?: CommissionBatchScalarFieldEnum | CommissionBatchScalarFieldEnum[]
  }

  /**
   * CommissionBatch create
   */
  export type CommissionBatchCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * The data needed to create a CommissionBatch.
     */
    data: XOR<CommissionBatchCreateInput, CommissionBatchUncheckedCreateInput>
  }

  /**
   * CommissionBatch createMany
   */
  export type CommissionBatchCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CommissionBatches.
     */
    data: CommissionBatchCreateManyInput | CommissionBatchCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CommissionBatch createManyAndReturn
   */
  export type CommissionBatchCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * The data used to create many CommissionBatches.
     */
    data: CommissionBatchCreateManyInput | CommissionBatchCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CommissionBatch update
   */
  export type CommissionBatchUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * The data needed to update a CommissionBatch.
     */
    data: XOR<CommissionBatchUpdateInput, CommissionBatchUncheckedUpdateInput>
    /**
     * Choose, which CommissionBatch to update.
     */
    where: CommissionBatchWhereUniqueInput
  }

  /**
   * CommissionBatch updateMany
   */
  export type CommissionBatchUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CommissionBatches.
     */
    data: XOR<CommissionBatchUpdateManyMutationInput, CommissionBatchUncheckedUpdateManyInput>
    /**
     * Filter which CommissionBatches to update
     */
    where?: CommissionBatchWhereInput
    /**
     * Limit how many CommissionBatches to update.
     */
    limit?: number
  }

  /**
   * CommissionBatch updateManyAndReturn
   */
  export type CommissionBatchUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * The data used to update CommissionBatches.
     */
    data: XOR<CommissionBatchUpdateManyMutationInput, CommissionBatchUncheckedUpdateManyInput>
    /**
     * Filter which CommissionBatches to update
     */
    where?: CommissionBatchWhereInput
    /**
     * Limit how many CommissionBatches to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * CommissionBatch upsert
   */
  export type CommissionBatchUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * The filter to search for the CommissionBatch to update in case it exists.
     */
    where: CommissionBatchWhereUniqueInput
    /**
     * In case the CommissionBatch found by the `where` argument doesn't exist, create a new CommissionBatch with this data.
     */
    create: XOR<CommissionBatchCreateInput, CommissionBatchUncheckedCreateInput>
    /**
     * In case the CommissionBatch was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommissionBatchUpdateInput, CommissionBatchUncheckedUpdateInput>
  }

  /**
   * CommissionBatch delete
   */
  export type CommissionBatchDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
    /**
     * Filter which CommissionBatch to delete.
     */
    where: CommissionBatchWhereUniqueInput
  }

  /**
   * CommissionBatch deleteMany
   */
  export type CommissionBatchDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommissionBatches to delete
     */
    where?: CommissionBatchWhereInput
    /**
     * Limit how many CommissionBatches to delete.
     */
    limit?: number
  }

  /**
   * CommissionBatch.items
   */
  export type CommissionBatch$itemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    where?: CommissionBatchItemWhereInput
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    cursor?: CommissionBatchItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommissionBatchItemScalarFieldEnum | CommissionBatchItemScalarFieldEnum[]
  }

  /**
   * CommissionBatch without action
   */
  export type CommissionBatchDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatch
     */
    select?: CommissionBatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatch
     */
    omit?: CommissionBatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchInclude<ExtArgs> | null
  }


  /**
   * Model CommissionBatchItem
   */

  export type AggregateCommissionBatchItem = {
    _count: CommissionBatchItemCountAggregateOutputType | null
    _avg: CommissionBatchItemAvgAggregateOutputType | null
    _sum: CommissionBatchItemSumAggregateOutputType | null
    _min: CommissionBatchItemMinAggregateOutputType | null
    _max: CommissionBatchItemMaxAggregateOutputType | null
  }

  export type CommissionBatchItemAvgAggregateOutputType = {
    id: number | null
    commissionBatchId: number | null
    paymentId: number | null
    collectionAmount: Decimal | null
  }

  export type CommissionBatchItemSumAggregateOutputType = {
    id: number | null
    commissionBatchId: number | null
    paymentId: number | null
    collectionAmount: Decimal | null
  }

  export type CommissionBatchItemMinAggregateOutputType = {
    id: number | null
    commissionBatchId: number | null
    paymentId: number | null
    collectionAmount: Decimal | null
  }

  export type CommissionBatchItemMaxAggregateOutputType = {
    id: number | null
    commissionBatchId: number | null
    paymentId: number | null
    collectionAmount: Decimal | null
  }

  export type CommissionBatchItemCountAggregateOutputType = {
    id: number
    commissionBatchId: number
    paymentId: number
    collectionAmount: number
    _all: number
  }


  export type CommissionBatchItemAvgAggregateInputType = {
    id?: true
    commissionBatchId?: true
    paymentId?: true
    collectionAmount?: true
  }

  export type CommissionBatchItemSumAggregateInputType = {
    id?: true
    commissionBatchId?: true
    paymentId?: true
    collectionAmount?: true
  }

  export type CommissionBatchItemMinAggregateInputType = {
    id?: true
    commissionBatchId?: true
    paymentId?: true
    collectionAmount?: true
  }

  export type CommissionBatchItemMaxAggregateInputType = {
    id?: true
    commissionBatchId?: true
    paymentId?: true
    collectionAmount?: true
  }

  export type CommissionBatchItemCountAggregateInputType = {
    id?: true
    commissionBatchId?: true
    paymentId?: true
    collectionAmount?: true
    _all?: true
  }

  export type CommissionBatchItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommissionBatchItem to aggregate.
     */
    where?: CommissionBatchItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatchItems to fetch.
     */
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CommissionBatchItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatchItems 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` CommissionBatchItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CommissionBatchItems
    **/
    _count?: true | CommissionBatchItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CommissionBatchItemAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CommissionBatchItemSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CommissionBatchItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CommissionBatchItemMaxAggregateInputType
  }

  export type GetCommissionBatchItemAggregateType<T extends CommissionBatchItemAggregateArgs> = {
        [P in keyof T & keyof AggregateCommissionBatchItem]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCommissionBatchItem[P]>
      : GetScalarType<T[P], AggregateCommissionBatchItem[P]>
  }




  export type CommissionBatchItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionBatchItemWhereInput
    orderBy?: CommissionBatchItemOrderByWithAggregationInput | CommissionBatchItemOrderByWithAggregationInput[]
    by: CommissionBatchItemScalarFieldEnum[] | CommissionBatchItemScalarFieldEnum
    having?: CommissionBatchItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommissionBatchItemCountAggregateInputType | true
    _avg?: CommissionBatchItemAvgAggregateInputType
    _sum?: CommissionBatchItemSumAggregateInputType
    _min?: CommissionBatchItemMinAggregateInputType
    _max?: CommissionBatchItemMaxAggregateInputType
  }

  export type CommissionBatchItemGroupByOutputType = {
    id: number
    commissionBatchId: number
    paymentId: number
    collectionAmount: Decimal
    _count: CommissionBatchItemCountAggregateOutputType | null
    _avg: CommissionBatchItemAvgAggregateOutputType | null
    _sum: CommissionBatchItemSumAggregateOutputType | null
    _min: CommissionBatchItemMinAggregateOutputType | null
    _max: CommissionBatchItemMaxAggregateOutputType | null
  }

  type GetCommissionBatchItemGroupByPayload<T extends CommissionBatchItemGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CommissionBatchItemGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CommissionBatchItemGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CommissionBatchItemGroupByOutputType[P]>
            : GetScalarType<T[P], CommissionBatchItemGroupByOutputType[P]>
        }
      >
    >


  export type CommissionBatchItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    commissionBatchId?: boolean
    paymentId?: boolean
    collectionAmount?: boolean
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatchItem"]>

  export type CommissionBatchItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    commissionBatchId?: boolean
    paymentId?: boolean
    collectionAmount?: boolean
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatchItem"]>

  export type CommissionBatchItemSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    commissionBatchId?: boolean
    paymentId?: boolean
    collectionAmount?: boolean
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commissionBatchItem"]>

  export type CommissionBatchItemSelectScalar = {
    id?: boolean
    commissionBatchId?: boolean
    paymentId?: boolean
    collectionAmount?: boolean
  }

  export type CommissionBatchItemOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "commissionBatchId" | "paymentId" | "collectionAmount", ExtArgs["result"]["commissionBatchItem"]>
  export type CommissionBatchItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }
  export type CommissionBatchItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }
  export type CommissionBatchItemIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    commissionBatch?: boolean | CommissionBatchDefaultArgs<ExtArgs>
    payment?: boolean | PaymentDefaultArgs<ExtArgs>
  }

  export type $CommissionBatchItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CommissionBatchItem"
    objects: {
      commissionBatch: Prisma.$CommissionBatchPayload<ExtArgs>
      payment: Prisma.$PaymentPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      commissionBatchId: number
      paymentId: number
      collectionAmount: Prisma.Decimal
    }, ExtArgs["result"]["commissionBatchItem"]>
    composites: {}
  }

  type CommissionBatchItemGetPayload<S extends boolean | null | undefined | CommissionBatchItemDefaultArgs> = $Result.GetResult<Prisma.$CommissionBatchItemPayload, S>

  type CommissionBatchItemCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<CommissionBatchItemFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: CommissionBatchItemCountAggregateInputType | true
    }

  export interface CommissionBatchItemDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['CommissionBatchItem'], meta: { name: 'CommissionBatchItem' } }
    /**
     * Find zero or one CommissionBatchItem that matches the filter.
     * @param {CommissionBatchItemFindUniqueArgs} args - Arguments to find a CommissionBatchItem
     * @example
     * // Get one CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends CommissionBatchItemFindUniqueArgs>(args: SelectSubset<T, CommissionBatchItemFindUniqueArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one CommissionBatchItem that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {CommissionBatchItemFindUniqueOrThrowArgs} args - Arguments to find a CommissionBatchItem
     * @example
     * // Get one CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends CommissionBatchItemFindUniqueOrThrowArgs>(args: SelectSubset<T, CommissionBatchItemFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first CommissionBatchItem 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 {CommissionBatchItemFindFirstArgs} args - Arguments to find a CommissionBatchItem
     * @example
     * // Get one CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends CommissionBatchItemFindFirstArgs>(args?: SelectSubset<T, CommissionBatchItemFindFirstArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first CommissionBatchItem 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 {CommissionBatchItemFindFirstOrThrowArgs} args - Arguments to find a CommissionBatchItem
     * @example
     * // Get one CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends CommissionBatchItemFindFirstOrThrowArgs>(args?: SelectSubset<T, CommissionBatchItemFindFirstOrThrowArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more CommissionBatchItems 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 {CommissionBatchItemFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all CommissionBatchItems
     * const commissionBatchItems = await prisma.commissionBatchItem.findMany()
     * 
     * // Get first 10 CommissionBatchItems
     * const commissionBatchItems = await prisma.commissionBatchItem.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const commissionBatchItemWithIdOnly = await prisma.commissionBatchItem.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends CommissionBatchItemFindManyArgs>(args?: SelectSubset<T, CommissionBatchItemFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a CommissionBatchItem.
     * @param {CommissionBatchItemCreateArgs} args - Arguments to create a CommissionBatchItem.
     * @example
     * // Create one CommissionBatchItem
     * const CommissionBatchItem = await prisma.commissionBatchItem.create({
     *   data: {
     *     // ... data to create a CommissionBatchItem
     *   }
     * })
     * 
     */
    create<T extends CommissionBatchItemCreateArgs>(args: SelectSubset<T, CommissionBatchItemCreateArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many CommissionBatchItems.
     * @param {CommissionBatchItemCreateManyArgs} args - Arguments to create many CommissionBatchItems.
     * @example
     * // Create many CommissionBatchItems
     * const commissionBatchItem = await prisma.commissionBatchItem.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends CommissionBatchItemCreateManyArgs>(args?: SelectSubset<T, CommissionBatchItemCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many CommissionBatchItems and returns the data saved in the database.
     * @param {CommissionBatchItemCreateManyAndReturnArgs} args - Arguments to create many CommissionBatchItems.
     * @example
     * // Create many CommissionBatchItems
     * const commissionBatchItem = await prisma.commissionBatchItem.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CommissionBatchItems and only return the `id`
     * const commissionBatchItemWithIdOnly = await prisma.commissionBatchItem.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 CommissionBatchItemCreateManyAndReturnArgs>(args?: SelectSubset<T, CommissionBatchItemCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CommissionBatchItem.
     * @param {CommissionBatchItemDeleteArgs} args - Arguments to delete one CommissionBatchItem.
     * @example
     * // Delete one CommissionBatchItem
     * const CommissionBatchItem = await prisma.commissionBatchItem.delete({
     *   where: {
     *     // ... filter to delete one CommissionBatchItem
     *   }
     * })
     * 
     */
    delete<T extends CommissionBatchItemDeleteArgs>(args: SelectSubset<T, CommissionBatchItemDeleteArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one CommissionBatchItem.
     * @param {CommissionBatchItemUpdateArgs} args - Arguments to update one CommissionBatchItem.
     * @example
     * // Update one CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CommissionBatchItemUpdateArgs>(args: SelectSubset<T, CommissionBatchItemUpdateArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more CommissionBatchItems.
     * @param {CommissionBatchItemDeleteManyArgs} args - Arguments to filter CommissionBatchItems to delete.
     * @example
     * // Delete a few CommissionBatchItems
     * const { count } = await prisma.commissionBatchItem.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends CommissionBatchItemDeleteManyArgs>(args?: SelectSubset<T, CommissionBatchItemDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CommissionBatchItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchItemUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many CommissionBatchItems
     * const commissionBatchItem = await prisma.commissionBatchItem.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends CommissionBatchItemUpdateManyArgs>(args: SelectSubset<T, CommissionBatchItemUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CommissionBatchItems and returns the data updated in the database.
     * @param {CommissionBatchItemUpdateManyAndReturnArgs} args - Arguments to update many CommissionBatchItems.
     * @example
     * // Update many CommissionBatchItems
     * const commissionBatchItem = await prisma.commissionBatchItem.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more CommissionBatchItems and only return the `id`
     * const commissionBatchItemWithIdOnly = await prisma.commissionBatchItem.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CommissionBatchItemUpdateManyAndReturnArgs>(args: SelectSubset<T, CommissionBatchItemUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one CommissionBatchItem.
     * @param {CommissionBatchItemUpsertArgs} args - Arguments to update or create a CommissionBatchItem.
     * @example
     * // Update or create a CommissionBatchItem
     * const commissionBatchItem = await prisma.commissionBatchItem.upsert({
     *   create: {
     *     // ... data to create a CommissionBatchItem
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the CommissionBatchItem we want to update
     *   }
     * })
     */
    upsert<T extends CommissionBatchItemUpsertArgs>(args: SelectSubset<T, CommissionBatchItemUpsertArgs<ExtArgs>>): Prisma__CommissionBatchItemClient<$Result.GetResult<Prisma.$CommissionBatchItemPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of CommissionBatchItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchItemCountArgs} args - Arguments to filter CommissionBatchItems to count.
     * @example
     * // Count the number of CommissionBatchItems
     * const count = await prisma.commissionBatchItem.count({
     *   where: {
     *     // ... the filter for the CommissionBatchItems we want to count
     *   }
     * })
    **/
    count<T extends CommissionBatchItemCountArgs>(
      args?: Subset<T, CommissionBatchItemCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CommissionBatchItemCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a CommissionBatchItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchItemAggregateArgs} 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 CommissionBatchItemAggregateArgs>(args: Subset<T, CommissionBatchItemAggregateArgs>): Prisma.PrismaPromise<GetCommissionBatchItemAggregateType<T>>

    /**
     * Group by CommissionBatchItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CommissionBatchItemGroupByArgs} 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 CommissionBatchItemGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CommissionBatchItemGroupByArgs['orderBy'] }
        : { orderBy?: CommissionBatchItemGroupByArgs['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, CommissionBatchItemGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCommissionBatchItemGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the CommissionBatchItem model
   */
  readonly fields: CommissionBatchItemFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for CommissionBatchItem.
   * 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__CommissionBatchItemClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    commissionBatch<T extends CommissionBatchDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CommissionBatchDefaultArgs<ExtArgs>>): Prisma__CommissionBatchClient<$Result.GetResult<Prisma.$CommissionBatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    payment<T extends PaymentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PaymentDefaultArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CommissionBatchItem model
   */
  interface CommissionBatchItemFieldRefs {
    readonly id: FieldRef<"CommissionBatchItem", 'Int'>
    readonly commissionBatchId: FieldRef<"CommissionBatchItem", 'Int'>
    readonly paymentId: FieldRef<"CommissionBatchItem", 'Int'>
    readonly collectionAmount: FieldRef<"CommissionBatchItem", 'Decimal'>
  }
    

  // Custom InputTypes
  /**
   * CommissionBatchItem findUnique
   */
  export type CommissionBatchItemFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatchItem to fetch.
     */
    where: CommissionBatchItemWhereUniqueInput
  }

  /**
   * CommissionBatchItem findUniqueOrThrow
   */
  export type CommissionBatchItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatchItem to fetch.
     */
    where: CommissionBatchItemWhereUniqueInput
  }

  /**
   * CommissionBatchItem findFirst
   */
  export type CommissionBatchItemFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatchItem to fetch.
     */
    where?: CommissionBatchItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatchItems to fetch.
     */
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CommissionBatchItems.
     */
    cursor?: CommissionBatchItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatchItems 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` CommissionBatchItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CommissionBatchItems.
     */
    distinct?: CommissionBatchItemScalarFieldEnum | CommissionBatchItemScalarFieldEnum[]
  }

  /**
   * CommissionBatchItem findFirstOrThrow
   */
  export type CommissionBatchItemFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatchItem to fetch.
     */
    where?: CommissionBatchItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatchItems to fetch.
     */
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CommissionBatchItems.
     */
    cursor?: CommissionBatchItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatchItems 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` CommissionBatchItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CommissionBatchItems.
     */
    distinct?: CommissionBatchItemScalarFieldEnum | CommissionBatchItemScalarFieldEnum[]
  }

  /**
   * CommissionBatchItem findMany
   */
  export type CommissionBatchItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter, which CommissionBatchItems to fetch.
     */
    where?: CommissionBatchItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommissionBatchItems to fetch.
     */
    orderBy?: CommissionBatchItemOrderByWithRelationInput | CommissionBatchItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CommissionBatchItems.
     */
    cursor?: CommissionBatchItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommissionBatchItems 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` CommissionBatchItems.
     */
    skip?: number
    distinct?: CommissionBatchItemScalarFieldEnum | CommissionBatchItemScalarFieldEnum[]
  }

  /**
   * CommissionBatchItem create
   */
  export type CommissionBatchItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * The data needed to create a CommissionBatchItem.
     */
    data: XOR<CommissionBatchItemCreateInput, CommissionBatchItemUncheckedCreateInput>
  }

  /**
   * CommissionBatchItem createMany
   */
  export type CommissionBatchItemCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CommissionBatchItems.
     */
    data: CommissionBatchItemCreateManyInput | CommissionBatchItemCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CommissionBatchItem createManyAndReturn
   */
  export type CommissionBatchItemCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * The data used to create many CommissionBatchItems.
     */
    data: CommissionBatchItemCreateManyInput | CommissionBatchItemCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CommissionBatchItem update
   */
  export type CommissionBatchItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * The data needed to update a CommissionBatchItem.
     */
    data: XOR<CommissionBatchItemUpdateInput, CommissionBatchItemUncheckedUpdateInput>
    /**
     * Choose, which CommissionBatchItem to update.
     */
    where: CommissionBatchItemWhereUniqueInput
  }

  /**
   * CommissionBatchItem updateMany
   */
  export type CommissionBatchItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CommissionBatchItems.
     */
    data: XOR<CommissionBatchItemUpdateManyMutationInput, CommissionBatchItemUncheckedUpdateManyInput>
    /**
     * Filter which CommissionBatchItems to update
     */
    where?: CommissionBatchItemWhereInput
    /**
     * Limit how many CommissionBatchItems to update.
     */
    limit?: number
  }

  /**
   * CommissionBatchItem updateManyAndReturn
   */
  export type CommissionBatchItemUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * The data used to update CommissionBatchItems.
     */
    data: XOR<CommissionBatchItemUpdateManyMutationInput, CommissionBatchItemUncheckedUpdateManyInput>
    /**
     * Filter which CommissionBatchItems to update
     */
    where?: CommissionBatchItemWhereInput
    /**
     * Limit how many CommissionBatchItems to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * CommissionBatchItem upsert
   */
  export type CommissionBatchItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * The filter to search for the CommissionBatchItem to update in case it exists.
     */
    where: CommissionBatchItemWhereUniqueInput
    /**
     * In case the CommissionBatchItem found by the `where` argument doesn't exist, create a new CommissionBatchItem with this data.
     */
    create: XOR<CommissionBatchItemCreateInput, CommissionBatchItemUncheckedCreateInput>
    /**
     * In case the CommissionBatchItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommissionBatchItemUpdateInput, CommissionBatchItemUncheckedUpdateInput>
  }

  /**
   * CommissionBatchItem delete
   */
  export type CommissionBatchItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<ExtArgs> | null
    /**
     * Filter which CommissionBatchItem to delete.
     */
    where: CommissionBatchItemWhereUniqueInput
  }

  /**
   * CommissionBatchItem deleteMany
   */
  export type CommissionBatchItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommissionBatchItems to delete
     */
    where?: CommissionBatchItemWhereInput
    /**
     * Limit how many CommissionBatchItems to delete.
     */
    limit?: number
  }

  /**
   * CommissionBatchItem without action
   */
  export type CommissionBatchItemDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommissionBatchItem
     */
    select?: CommissionBatchItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommissionBatchItem
     */
    omit?: CommissionBatchItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommissionBatchItemInclude<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',
    username: 'username',
    password: 'password',
    autoBackupEnabled: 'autoBackupEnabled',
    usbBackupEnabled: 'usbBackupEnabled'
  };

  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]


  export const PatientScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    dateOfBirth: 'dateOfBirth',
    gender: 'gender',
    phone: 'phone',
    email: 'email',
    address: 'address',
    city: 'city',
    zipCode: 'zipCode',
    insuranceProvider: 'insuranceProvider',
    insuranceId: 'insuranceId',
    groupNumber: 'groupNumber',
    policyHolder: 'policyHolder',
    allergies: 'allergies',
    medicalConditions: 'medicalConditions',
    preferredLanguage: 'preferredLanguage',
    status: 'status',
    userId: 'userId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PatientScalarFieldEnum = (typeof PatientScalarFieldEnum)[keyof typeof PatientScalarFieldEnum]


  export const AppointmentScalarFieldEnum: {
    id: 'id',
    patientId: 'patientId',
    userId: 'userId',
    staffId: 'staffId',
    title: 'title',
    date: 'date',
    startTime: 'startTime',
    endTime: 'endTime',
    type: 'type',
    typeLocked: 'typeLocked',
    notes: 'notes',
    procedureCodeNotes: 'procedureCodeNotes',
    status: 'status',
    movedByAi: 'movedByAi',
    createdAt: 'createdAt',
    eligibilityStatus: 'eligibilityStatus'
  };

  export type AppointmentScalarFieldEnum = (typeof AppointmentScalarFieldEnum)[keyof typeof AppointmentScalarFieldEnum]


  export const AppointmentFileScalarFieldEnum: {
    id: 'id',
    appointmentId: 'appointmentId',
    filename: 'filename',
    mimeType: 'mimeType',
    filePath: 'filePath'
  };

  export type AppointmentFileScalarFieldEnum = (typeof AppointmentFileScalarFieldEnum)[keyof typeof AppointmentFileScalarFieldEnum]


  export const StaffScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    name: 'name',
    email: 'email',
    role: 'role',
    phone: 'phone',
    createdAt: 'createdAt'
  };

  export type StaffScalarFieldEnum = (typeof StaffScalarFieldEnum)[keyof typeof StaffScalarFieldEnum]


  export const NpiProviderScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    npiNumber: 'npiNumber',
    providerName: 'providerName',
    createdAt: 'createdAt'
  };

  export type NpiProviderScalarFieldEnum = (typeof NpiProviderScalarFieldEnum)[keyof typeof NpiProviderScalarFieldEnum]


  export const AppointmentProcedureScalarFieldEnum: {
    id: 'id',
    appointmentId: 'appointmentId',
    patientId: 'patientId',
    npiProviderId: 'npiProviderId',
    procedureCode: 'procedureCode',
    procedureLabel: 'procedureLabel',
    fee: 'fee',
    category: 'category',
    toothNumber: 'toothNumber',
    toothSurface: 'toothSurface',
    oralCavityArea: 'oralCavityArea',
    source: 'source',
    comboKey: 'comboKey',
    createdAt: 'createdAt'
  };

  export type AppointmentProcedureScalarFieldEnum = (typeof AppointmentProcedureScalarFieldEnum)[keyof typeof AppointmentProcedureScalarFieldEnum]


  export const ClaimScalarFieldEnum: {
    id: 'id',
    patientId: 'patientId',
    appointmentId: 'appointmentId',
    userId: 'userId',
    staffId: 'staffId',
    patientName: 'patientName',
    memberId: 'memberId',
    dateOfBirth: 'dateOfBirth',
    remarks: 'remarks',
    missingTeethStatus: 'missingTeethStatus',
    missingTeeth: 'missingTeeth',
    serviceDate: 'serviceDate',
    insuranceProvider: 'insuranceProvider',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    status: 'status',
    claimNumber: 'claimNumber',
    preAuthNumber: 'preAuthNumber',
    npiProviderId: 'npiProviderId'
  };

  export type ClaimScalarFieldEnum = (typeof ClaimScalarFieldEnum)[keyof typeof ClaimScalarFieldEnum]


  export const ServiceLineScalarFieldEnum: {
    id: 'id',
    claimId: 'claimId',
    paymentId: 'paymentId',
    procedureCode: 'procedureCode',
    procedureDate: 'procedureDate',
    quad: 'quad',
    arch: 'arch',
    toothNumber: 'toothNumber',
    toothSurface: 'toothSurface',
    icn: 'icn',
    paidCode: 'paidCode',
    allowedAmount: 'allowedAmount',
    totalBilled: 'totalBilled',
    totalPaid: 'totalPaid',
    totalAdjusted: 'totalAdjusted',
    totalDue: 'totalDue',
    status: 'status'
  };

  export type ServiceLineScalarFieldEnum = (typeof ServiceLineScalarFieldEnum)[keyof typeof ServiceLineScalarFieldEnum]


  export const ClaimFileScalarFieldEnum: {
    id: 'id',
    claimId: 'claimId',
    filename: 'filename',
    mimeType: 'mimeType',
    filePath: 'filePath'
  };

  export type ClaimFileScalarFieldEnum = (typeof ClaimFileScalarFieldEnum)[keyof typeof ClaimFileScalarFieldEnum]


  export const InsuranceCredentialScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    siteKey: 'siteKey',
    username: 'username',
    password: 'password'
  };

  export type InsuranceCredentialScalarFieldEnum = (typeof InsuranceCredentialScalarFieldEnum)[keyof typeof InsuranceCredentialScalarFieldEnum]


  export const ShoppingVendorScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    vendorName: 'vendorName',
    websiteUrl: 'websiteUrl',
    loginUsername: 'loginUsername',
    loginPassword: 'loginPassword'
  };

  export type ShoppingVendorScalarFieldEnum = (typeof ShoppingVendorScalarFieldEnum)[keyof typeof ShoppingVendorScalarFieldEnum]


  export const PdfGroupScalarFieldEnum: {
    id: 'id',
    title: 'title',
    titleKey: 'titleKey',
    createdAt: 'createdAt',
    patientId: 'patientId'
  };

  export type PdfGroupScalarFieldEnum = (typeof PdfGroupScalarFieldEnum)[keyof typeof PdfGroupScalarFieldEnum]


  export const PdfFileScalarFieldEnum: {
    id: 'id',
    filename: 'filename',
    pdfData: 'pdfData',
    uploadedAt: 'uploadedAt',
    groupId: 'groupId'
  };

  export type PdfFileScalarFieldEnum = (typeof PdfFileScalarFieldEnum)[keyof typeof PdfFileScalarFieldEnum]


  export const PaymentScalarFieldEnum: {
    id: 'id',
    claimId: 'claimId',
    patientId: 'patientId',
    userId: 'userId',
    updatedById: 'updatedById',
    npiProviderId: 'npiProviderId',
    totalBilled: 'totalBilled',
    totalPaid: 'totalPaid',
    totalAdjusted: 'totalAdjusted',
    totalDue: 'totalDue',
    mhPaidAmount: 'mhPaidAmount',
    copayment: 'copayment',
    adjustment: 'adjustment',
    status: 'status',
    notes: 'notes',
    icn: 'icn',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PaymentScalarFieldEnum = (typeof PaymentScalarFieldEnum)[keyof typeof PaymentScalarFieldEnum]


  export const ServiceLineTransactionScalarFieldEnum: {
    id: 'id',
    paymentId: 'paymentId',
    serviceLineId: 'serviceLineId',
    transactionId: 'transactionId',
    paidAmount: 'paidAmount',
    adjustedAmount: 'adjustedAmount',
    method: 'method',
    receivedDate: 'receivedDate',
    payerName: 'payerName',
    notes: 'notes',
    createdAt: 'createdAt'
  };

  export type ServiceLineTransactionScalarFieldEnum = (typeof ServiceLineTransactionScalarFieldEnum)[keyof typeof ServiceLineTransactionScalarFieldEnum]


  export const DatabaseBackupScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    createdAt: 'createdAt'
  };

  export type DatabaseBackupScalarFieldEnum = (typeof DatabaseBackupScalarFieldEnum)[keyof typeof DatabaseBackupScalarFieldEnum]


  export const BackupDestinationScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    path: 'path',
    isActive: 'isActive',
    createdAt: 'createdAt'
  };

  export type BackupDestinationScalarFieldEnum = (typeof BackupDestinationScalarFieldEnum)[keyof typeof BackupDestinationScalarFieldEnum]


  export const NotificationScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    type: 'type',
    message: 'message',
    createdAt: 'createdAt',
    read: 'read'
  };

  export type NotificationScalarFieldEnum = (typeof NotificationScalarFieldEnum)[keyof typeof NotificationScalarFieldEnum]


  export const CronJobLogScalarFieldEnum: {
    id: 'id',
    jobName: 'jobName',
    status: 'status',
    startedAt: 'startedAt',
    completedAt: 'completedAt',
    durationMs: 'durationMs',
    errorMessage: 'errorMessage'
  };

  export type CronJobLogScalarFieldEnum = (typeof CronJobLogScalarFieldEnum)[keyof typeof CronJobLogScalarFieldEnum]


  export const CloudFolderScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    name: 'name',
    parentId: 'parentId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type CloudFolderScalarFieldEnum = (typeof CloudFolderScalarFieldEnum)[keyof typeof CloudFolderScalarFieldEnum]


  export const CloudFileScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    name: 'name',
    mimeType: 'mimeType',
    fileSize: 'fileSize',
    folderId: 'folderId',
    isComplete: 'isComplete',
    totalChunks: 'totalChunks',
    diskPath: 'diskPath',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type CloudFileScalarFieldEnum = (typeof CloudFileScalarFieldEnum)[keyof typeof CloudFileScalarFieldEnum]


  export const CloudFileChunkScalarFieldEnum: {
    id: 'id',
    fileId: 'fileId',
    seq: 'seq',
    data: 'data',
    createdAt: 'createdAt'
  };

  export type CloudFileChunkScalarFieldEnum = (typeof CloudFileChunkScalarFieldEnum)[keyof typeof CloudFileChunkScalarFieldEnum]


  export const CommunicationScalarFieldEnum: {
    id: 'id',
    patientId: 'patientId',
    userId: 'userId',
    channel: 'channel',
    direction: 'direction',
    status: 'status',
    body: 'body',
    callDuration: 'callDuration',
    twilioSid: 'twilioSid',
    createdAt: 'createdAt'
  };

  export type CommunicationScalarFieldEnum = (typeof CommunicationScalarFieldEnum)[keyof typeof CommunicationScalarFieldEnum]


  export const PatientDocumentScalarFieldEnum: {
    id: 'id',
    patientId: 'patientId',
    filename: 'filename',
    originalName: 'originalName',
    mimeType: 'mimeType',
    fileSize: 'fileSize',
    filePath: 'filePath',
    uploadedAt: 'uploadedAt',
    updatedAt: 'updatedAt'
  };

  export type PatientDocumentScalarFieldEnum = (typeof PatientDocumentScalarFieldEnum)[keyof typeof PatientDocumentScalarFieldEnum]


  export const TwilioSettingsScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    accountSid: 'accountSid',
    authToken: 'authToken',
    phoneNumber: 'phoneNumber',
    greetingMessage: 'greetingMessage',
    templates: 'templates'
  };

  export type TwilioSettingsScalarFieldEnum = (typeof TwilioSettingsScalarFieldEnum)[keyof typeof TwilioSettingsScalarFieldEnum]


  export const AiSettingsScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    apiKey: 'apiKey',
    afterHoursEnabled: 'afterHoursEnabled',
    openPhoneReply: 'openPhoneReply'
  };

  export type AiSettingsScalarFieldEnum = (typeof AiSettingsScalarFieldEnum)[keyof typeof AiSettingsScalarFieldEnum]


  export const OfficeHoursScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    data: 'data'
  };

  export type OfficeHoursScalarFieldEnum = (typeof OfficeHoursScalarFieldEnum)[keyof typeof OfficeHoursScalarFieldEnum]


  export const OfficeContactScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    officeName: 'officeName',
    receptionistName: 'receptionistName',
    dentistName: 'dentistName',
    phoneNumber: 'phoneNumber',
    email: 'email',
    fax: 'fax',
    streetAddress: 'streetAddress',
    city: 'city',
    state: 'state',
    zipCode: 'zipCode'
  };

  export type OfficeContactScalarFieldEnum = (typeof OfficeContactScalarFieldEnum)[keyof typeof OfficeContactScalarFieldEnum]


  export const InsuranceContactScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    name: 'name',
    phoneNumber: 'phoneNumber',
    createdAt: 'createdAt'
  };

  export type InsuranceContactScalarFieldEnum = (typeof InsuranceContactScalarFieldEnum)[keyof typeof InsuranceContactScalarFieldEnum]


  export const ProcedureTimeslotScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    data: 'data'
  };

  export type ProcedureTimeslotScalarFieldEnum = (typeof ProcedureTimeslotScalarFieldEnum)[keyof typeof ProcedureTimeslotScalarFieldEnum]


  export const PatientConversationScalarFieldEnum: {
    id: 'id',
    patientId: 'patientId',
    userId: 'userId',
    stage: 'stage',
    aiHandoff: 'aiHandoff',
    updatedAt: 'updatedAt'
  };

  export type PatientConversationScalarFieldEnum = (typeof PatientConversationScalarFieldEnum)[keyof typeof PatientConversationScalarFieldEnum]


  export const CommissionBatchScalarFieldEnum: {
    id: 'id',
    npiProviderId: 'npiProviderId',
    totalCollection: 'totalCollection',
    commissionAmount: 'commissionAmount',
    notes: 'notes',
    createdAt: 'createdAt'
  };

  export type CommissionBatchScalarFieldEnum = (typeof CommissionBatchScalarFieldEnum)[keyof typeof CommissionBatchScalarFieldEnum]


  export const CommissionBatchItemScalarFieldEnum: {
    id: 'id',
    commissionBatchId: 'commissionBatchId',
    paymentId: 'paymentId',
    collectionAmount: 'collectionAmount'
  };

  export type CommissionBatchItemScalarFieldEnum = (typeof CommissionBatchItemScalarFieldEnum)[keyof typeof CommissionBatchItemScalarFieldEnum]


  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 NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

  export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]


  /**
   * Field references
   */


  /**
   * 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 '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 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * 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 'PatientStatus'
   */
  export type EnumPatientStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PatientStatus'>
    


  /**
   * Reference to a field of type 'PatientStatus[]'
   */
  export type ListEnumPatientStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PatientStatus[]'>
    


  /**
   * Reference to a field of type 'Decimal'
   */
  export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>
    


  /**
   * Reference to a field of type 'Decimal[]'
   */
  export type ListDecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal[]'>
    


  /**
   * Reference to a field of type 'ProcedureSource'
   */
  export type EnumProcedureSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProcedureSource'>
    


  /**
   * Reference to a field of type 'ProcedureSource[]'
   */
  export type ListEnumProcedureSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProcedureSource[]'>
    


  /**
   * Reference to a field of type 'MissingTeethStatus'
   */
  export type EnumMissingTeethStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MissingTeethStatus'>
    


  /**
   * Reference to a field of type 'MissingTeethStatus[]'
   */
  export type ListEnumMissingTeethStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MissingTeethStatus[]'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'QueryMode'
   */
  export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
    


  /**
   * Reference to a field of type 'ClaimStatus'
   */
  export type EnumClaimStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ClaimStatus'>
    


  /**
   * Reference to a field of type 'ClaimStatus[]'
   */
  export type ListEnumClaimStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ClaimStatus[]'>
    


  /**
   * Reference to a field of type 'ServiceLineStatus'
   */
  export type EnumServiceLineStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ServiceLineStatus'>
    


  /**
   * Reference to a field of type 'ServiceLineStatus[]'
   */
  export type ListEnumServiceLineStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ServiceLineStatus[]'>
    


  /**
   * Reference to a field of type 'PdfTitleKey'
   */
  export type EnumPdfTitleKeyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PdfTitleKey'>
    


  /**
   * Reference to a field of type 'PdfTitleKey[]'
   */
  export type ListEnumPdfTitleKeyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PdfTitleKey[]'>
    


  /**
   * Reference to a field of type 'Bytes'
   */
  export type BytesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Bytes'>
    


  /**
   * Reference to a field of type 'Bytes[]'
   */
  export type ListBytesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Bytes[]'>
    


  /**
   * Reference to a field of type 'PaymentStatus'
   */
  export type EnumPaymentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentStatus'>
    


  /**
   * Reference to a field of type 'PaymentStatus[]'
   */
  export type ListEnumPaymentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentStatus[]'>
    


  /**
   * Reference to a field of type 'PaymentMethod'
   */
  export type EnumPaymentMethodFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentMethod'>
    


  /**
   * Reference to a field of type 'PaymentMethod[]'
   */
  export type ListEnumPaymentMethodFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentMethod[]'>
    


  /**
   * Reference to a field of type 'NotificationTypes'
   */
  export type EnumNotificationTypesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationTypes'>
    


  /**
   * Reference to a field of type 'NotificationTypes[]'
   */
  export type ListEnumNotificationTypesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationTypes[]'>
    


  /**
   * 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 'CommunicationChannel'
   */
  export type EnumCommunicationChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationChannel'>
    


  /**
   * Reference to a field of type 'CommunicationChannel[]'
   */
  export type ListEnumCommunicationChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationChannel[]'>
    


  /**
   * Reference to a field of type 'CommunicationDirection'
   */
  export type EnumCommunicationDirectionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationDirection'>
    


  /**
   * Reference to a field of type 'CommunicationDirection[]'
   */
  export type ListEnumCommunicationDirectionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationDirection[]'>
    


  /**
   * Reference to a field of type 'CommunicationStatus'
   */
  export type EnumCommunicationStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationStatus'>
    


  /**
   * Reference to a field of type 'CommunicationStatus[]'
   */
  export type ListEnumCommunicationStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommunicationStatus[]'>
    


  /**
   * 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?: IntFilter<"User"> | number
    username?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    autoBackupEnabled?: BoolFilter<"User"> | boolean
    usbBackupEnabled?: BoolFilter<"User"> | boolean
    patients?: PatientListRelationFilter
    appointments?: AppointmentListRelationFilter
    staff?: StaffListRelationFilter
    npiProviders?: NpiProviderListRelationFilter
    claims?: ClaimListRelationFilter
    insuranceCredentials?: InsuranceCredentialListRelationFilter
    shoppingVendors?: ShoppingVendorListRelationFilter
    updatedPayments?: PaymentListRelationFilter
    backups?: DatabaseBackupListRelationFilter
    backupDestinations?: BackupDestinationListRelationFilter
    notifications?: NotificationListRelationFilter
    cloudFolders?: CloudFolderListRelationFilter
    cloudFiles?: CloudFileListRelationFilter
    communications?: CommunicationListRelationFilter
    twilioSettings?: XOR<TwilioSettingsNullableScalarRelationFilter, TwilioSettingsWhereInput> | null
    aiSettings?: XOR<AiSettingsNullableScalarRelationFilter, AiSettingsWhereInput> | null
    officeHours?: XOR<OfficeHoursNullableScalarRelationFilter, OfficeHoursWhereInput> | null
    officeContact?: XOR<OfficeContactNullableScalarRelationFilter, OfficeContactWhereInput> | null
    procedureTimeslot?: XOR<ProcedureTimeslotNullableScalarRelationFilter, ProcedureTimeslotWhereInput> | null
    insuranceContacts?: InsuranceContactListRelationFilter
    patientConversations?: PatientConversationListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    autoBackupEnabled?: SortOrder
    usbBackupEnabled?: SortOrder
    patients?: PatientOrderByRelationAggregateInput
    appointments?: AppointmentOrderByRelationAggregateInput
    staff?: StaffOrderByRelationAggregateInput
    npiProviders?: NpiProviderOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
    insuranceCredentials?: InsuranceCredentialOrderByRelationAggregateInput
    shoppingVendors?: ShoppingVendorOrderByRelationAggregateInput
    updatedPayments?: PaymentOrderByRelationAggregateInput
    backups?: DatabaseBackupOrderByRelationAggregateInput
    backupDestinations?: BackupDestinationOrderByRelationAggregateInput
    notifications?: NotificationOrderByRelationAggregateInput
    cloudFolders?: CloudFolderOrderByRelationAggregateInput
    cloudFiles?: CloudFileOrderByRelationAggregateInput
    communications?: CommunicationOrderByRelationAggregateInput
    twilioSettings?: TwilioSettingsOrderByWithRelationInput
    aiSettings?: AiSettingsOrderByWithRelationInput
    officeHours?: OfficeHoursOrderByWithRelationInput
    officeContact?: OfficeContactOrderByWithRelationInput
    procedureTimeslot?: ProcedureTimeslotOrderByWithRelationInput
    insuranceContacts?: InsuranceContactOrderByRelationAggregateInput
    patientConversations?: PatientConversationOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    username?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    password?: StringFilter<"User"> | string
    autoBackupEnabled?: BoolFilter<"User"> | boolean
    usbBackupEnabled?: BoolFilter<"User"> | boolean
    patients?: PatientListRelationFilter
    appointments?: AppointmentListRelationFilter
    staff?: StaffListRelationFilter
    npiProviders?: NpiProviderListRelationFilter
    claims?: ClaimListRelationFilter
    insuranceCredentials?: InsuranceCredentialListRelationFilter
    shoppingVendors?: ShoppingVendorListRelationFilter
    updatedPayments?: PaymentListRelationFilter
    backups?: DatabaseBackupListRelationFilter
    backupDestinations?: BackupDestinationListRelationFilter
    notifications?: NotificationListRelationFilter
    cloudFolders?: CloudFolderListRelationFilter
    cloudFiles?: CloudFileListRelationFilter
    communications?: CommunicationListRelationFilter
    twilioSettings?: XOR<TwilioSettingsNullableScalarRelationFilter, TwilioSettingsWhereInput> | null
    aiSettings?: XOR<AiSettingsNullableScalarRelationFilter, AiSettingsWhereInput> | null
    officeHours?: XOR<OfficeHoursNullableScalarRelationFilter, OfficeHoursWhereInput> | null
    officeContact?: XOR<OfficeContactNullableScalarRelationFilter, OfficeContactWhereInput> | null
    procedureTimeslot?: XOR<ProcedureTimeslotNullableScalarRelationFilter, ProcedureTimeslotWhereInput> | null
    insuranceContacts?: InsuranceContactListRelationFilter
    patientConversations?: PatientConversationListRelationFilter
  }, "id" | "username">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    autoBackupEnabled?: SortOrder
    usbBackupEnabled?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _avg?: UserAvgOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
    _sum?: UserSumOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"User"> | number
    username?: StringWithAggregatesFilter<"User"> | string
    password?: StringWithAggregatesFilter<"User"> | string
    autoBackupEnabled?: BoolWithAggregatesFilter<"User"> | boolean
    usbBackupEnabled?: BoolWithAggregatesFilter<"User"> | boolean
  }

  export type PatientWhereInput = {
    AND?: PatientWhereInput | PatientWhereInput[]
    OR?: PatientWhereInput[]
    NOT?: PatientWhereInput | PatientWhereInput[]
    id?: IntFilter<"Patient"> | number
    firstName?: StringFilter<"Patient"> | string
    lastName?: StringFilter<"Patient"> | string
    dateOfBirth?: DateTimeNullableFilter<"Patient"> | Date | string | null
    gender?: StringFilter<"Patient"> | string
    phone?: StringFilter<"Patient"> | string
    email?: StringNullableFilter<"Patient"> | string | null
    address?: StringNullableFilter<"Patient"> | string | null
    city?: StringNullableFilter<"Patient"> | string | null
    zipCode?: StringNullableFilter<"Patient"> | string | null
    insuranceProvider?: StringNullableFilter<"Patient"> | string | null
    insuranceId?: StringNullableFilter<"Patient"> | string | null
    groupNumber?: StringNullableFilter<"Patient"> | string | null
    policyHolder?: StringNullableFilter<"Patient"> | string | null
    allergies?: StringNullableFilter<"Patient"> | string | null
    medicalConditions?: StringNullableFilter<"Patient"> | string | null
    preferredLanguage?: StringNullableFilter<"Patient"> | string | null
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: DateTimeFilter<"Patient"> | Date | string
    updatedAt?: DateTimeFilter<"Patient"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    appointments?: AppointmentListRelationFilter
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    groups?: PdfGroupListRelationFilter
    payment?: PaymentListRelationFilter
    communications?: CommunicationListRelationFilter
    documents?: PatientDocumentListRelationFilter
    conversation?: XOR<PatientConversationNullableScalarRelationFilter, PatientConversationWhereInput> | null
  }

  export type PatientOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: SortOrderInput | SortOrder
    gender?: SortOrder
    phone?: SortOrder
    email?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    zipCode?: SortOrderInput | SortOrder
    insuranceProvider?: SortOrderInput | SortOrder
    insuranceId?: SortOrderInput | SortOrder
    groupNumber?: SortOrderInput | SortOrder
    policyHolder?: SortOrderInput | SortOrder
    allergies?: SortOrderInput | SortOrder
    medicalConditions?: SortOrderInput | SortOrder
    preferredLanguage?: SortOrderInput | SortOrder
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    appointments?: AppointmentOrderByRelationAggregateInput
    procedures?: AppointmentProcedureOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
    groups?: PdfGroupOrderByRelationAggregateInput
    payment?: PaymentOrderByRelationAggregateInput
    communications?: CommunicationOrderByRelationAggregateInput
    documents?: PatientDocumentOrderByRelationAggregateInput
    conversation?: PatientConversationOrderByWithRelationInput
  }

  export type PatientWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PatientWhereInput | PatientWhereInput[]
    OR?: PatientWhereInput[]
    NOT?: PatientWhereInput | PatientWhereInput[]
    firstName?: StringFilter<"Patient"> | string
    lastName?: StringFilter<"Patient"> | string
    dateOfBirth?: DateTimeNullableFilter<"Patient"> | Date | string | null
    gender?: StringFilter<"Patient"> | string
    phone?: StringFilter<"Patient"> | string
    email?: StringNullableFilter<"Patient"> | string | null
    address?: StringNullableFilter<"Patient"> | string | null
    city?: StringNullableFilter<"Patient"> | string | null
    zipCode?: StringNullableFilter<"Patient"> | string | null
    insuranceProvider?: StringNullableFilter<"Patient"> | string | null
    insuranceId?: StringNullableFilter<"Patient"> | string | null
    groupNumber?: StringNullableFilter<"Patient"> | string | null
    policyHolder?: StringNullableFilter<"Patient"> | string | null
    allergies?: StringNullableFilter<"Patient"> | string | null
    medicalConditions?: StringNullableFilter<"Patient"> | string | null
    preferredLanguage?: StringNullableFilter<"Patient"> | string | null
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: DateTimeFilter<"Patient"> | Date | string
    updatedAt?: DateTimeFilter<"Patient"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    appointments?: AppointmentListRelationFilter
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    groups?: PdfGroupListRelationFilter
    payment?: PaymentListRelationFilter
    communications?: CommunicationListRelationFilter
    documents?: PatientDocumentListRelationFilter
    conversation?: XOR<PatientConversationNullableScalarRelationFilter, PatientConversationWhereInput> | null
  }, "id">

  export type PatientOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: SortOrderInput | SortOrder
    gender?: SortOrder
    phone?: SortOrder
    email?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    zipCode?: SortOrderInput | SortOrder
    insuranceProvider?: SortOrderInput | SortOrder
    insuranceId?: SortOrderInput | SortOrder
    groupNumber?: SortOrderInput | SortOrder
    policyHolder?: SortOrderInput | SortOrder
    allergies?: SortOrderInput | SortOrder
    medicalConditions?: SortOrderInput | SortOrder
    preferredLanguage?: SortOrderInput | SortOrder
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PatientCountOrderByAggregateInput
    _avg?: PatientAvgOrderByAggregateInput
    _max?: PatientMaxOrderByAggregateInput
    _min?: PatientMinOrderByAggregateInput
    _sum?: PatientSumOrderByAggregateInput
  }

  export type PatientScalarWhereWithAggregatesInput = {
    AND?: PatientScalarWhereWithAggregatesInput | PatientScalarWhereWithAggregatesInput[]
    OR?: PatientScalarWhereWithAggregatesInput[]
    NOT?: PatientScalarWhereWithAggregatesInput | PatientScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Patient"> | number
    firstName?: StringWithAggregatesFilter<"Patient"> | string
    lastName?: StringWithAggregatesFilter<"Patient"> | string
    dateOfBirth?: DateTimeNullableWithAggregatesFilter<"Patient"> | Date | string | null
    gender?: StringWithAggregatesFilter<"Patient"> | string
    phone?: StringWithAggregatesFilter<"Patient"> | string
    email?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    address?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    city?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    zipCode?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    insuranceProvider?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    insuranceId?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    groupNumber?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    policyHolder?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    allergies?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    medicalConditions?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    preferredLanguage?: StringNullableWithAggregatesFilter<"Patient"> | string | null
    status?: EnumPatientStatusWithAggregatesFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntWithAggregatesFilter<"Patient"> | number
    createdAt?: DateTimeWithAggregatesFilter<"Patient"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Patient"> | Date | string
  }

  export type AppointmentWhereInput = {
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    id?: IntFilter<"Appointment"> | number
    patientId?: IntFilter<"Appointment"> | number
    userId?: IntFilter<"Appointment"> | number
    staffId?: IntFilter<"Appointment"> | number
    title?: StringFilter<"Appointment"> | string
    date?: DateTimeFilter<"Appointment"> | Date | string
    startTime?: StringFilter<"Appointment"> | string
    endTime?: StringFilter<"Appointment"> | string
    type?: StringFilter<"Appointment"> | string
    typeLocked?: BoolFilter<"Appointment"> | boolean
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    movedByAi?: BoolFilter<"Appointment"> | boolean
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    eligibilityStatus?: EnumPatientStatusFilter<"Appointment"> | $Enums.PatientStatus
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    files?: AppointmentFileListRelationFilter
  }

  export type AppointmentOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    typeLocked?: SortOrder
    notes?: SortOrderInput | SortOrder
    procedureCodeNotes?: SortOrderInput | SortOrder
    status?: SortOrder
    movedByAi?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
    patient?: PatientOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    staff?: StaffOrderByWithRelationInput
    procedures?: AppointmentProcedureOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
    files?: AppointmentFileOrderByRelationAggregateInput
  }

  export type AppointmentWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    patientId?: IntFilter<"Appointment"> | number
    userId?: IntFilter<"Appointment"> | number
    staffId?: IntFilter<"Appointment"> | number
    title?: StringFilter<"Appointment"> | string
    date?: DateTimeFilter<"Appointment"> | Date | string
    startTime?: StringFilter<"Appointment"> | string
    endTime?: StringFilter<"Appointment"> | string
    type?: StringFilter<"Appointment"> | string
    typeLocked?: BoolFilter<"Appointment"> | boolean
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    movedByAi?: BoolFilter<"Appointment"> | boolean
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    eligibilityStatus?: EnumPatientStatusFilter<"Appointment"> | $Enums.PatientStatus
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    files?: AppointmentFileListRelationFilter
  }, "id">

  export type AppointmentOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    typeLocked?: SortOrder
    notes?: SortOrderInput | SortOrder
    procedureCodeNotes?: SortOrderInput | SortOrder
    status?: SortOrder
    movedByAi?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: 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
    patientId?: IntWithAggregatesFilter<"Appointment"> | number
    userId?: IntWithAggregatesFilter<"Appointment"> | number
    staffId?: IntWithAggregatesFilter<"Appointment"> | number
    title?: StringWithAggregatesFilter<"Appointment"> | string
    date?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    startTime?: StringWithAggregatesFilter<"Appointment"> | string
    endTime?: StringWithAggregatesFilter<"Appointment"> | string
    type?: StringWithAggregatesFilter<"Appointment"> | string
    typeLocked?: BoolWithAggregatesFilter<"Appointment"> | boolean
    notes?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
    status?: StringWithAggregatesFilter<"Appointment"> | string
    movedByAi?: BoolWithAggregatesFilter<"Appointment"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    eligibilityStatus?: EnumPatientStatusWithAggregatesFilter<"Appointment"> | $Enums.PatientStatus
  }

  export type AppointmentFileWhereInput = {
    AND?: AppointmentFileWhereInput | AppointmentFileWhereInput[]
    OR?: AppointmentFileWhereInput[]
    NOT?: AppointmentFileWhereInput | AppointmentFileWhereInput[]
    id?: IntFilter<"AppointmentFile"> | number
    appointmentId?: IntFilter<"AppointmentFile"> | number
    filename?: StringFilter<"AppointmentFile"> | string
    mimeType?: StringNullableFilter<"AppointmentFile"> | string | null
    filePath?: StringNullableFilter<"AppointmentFile"> | string | null
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
  }

  export type AppointmentFileOrderByWithRelationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrderInput | SortOrder
    filePath?: SortOrderInput | SortOrder
    appointment?: AppointmentOrderByWithRelationInput
  }

  export type AppointmentFileWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AppointmentFileWhereInput | AppointmentFileWhereInput[]
    OR?: AppointmentFileWhereInput[]
    NOT?: AppointmentFileWhereInput | AppointmentFileWhereInput[]
    appointmentId?: IntFilter<"AppointmentFile"> | number
    filename?: StringFilter<"AppointmentFile"> | string
    mimeType?: StringNullableFilter<"AppointmentFile"> | string | null
    filePath?: StringNullableFilter<"AppointmentFile"> | string | null
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
  }, "id">

  export type AppointmentFileOrderByWithAggregationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrderInput | SortOrder
    filePath?: SortOrderInput | SortOrder
    _count?: AppointmentFileCountOrderByAggregateInput
    _avg?: AppointmentFileAvgOrderByAggregateInput
    _max?: AppointmentFileMaxOrderByAggregateInput
    _min?: AppointmentFileMinOrderByAggregateInput
    _sum?: AppointmentFileSumOrderByAggregateInput
  }

  export type AppointmentFileScalarWhereWithAggregatesInput = {
    AND?: AppointmentFileScalarWhereWithAggregatesInput | AppointmentFileScalarWhereWithAggregatesInput[]
    OR?: AppointmentFileScalarWhereWithAggregatesInput[]
    NOT?: AppointmentFileScalarWhereWithAggregatesInput | AppointmentFileScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"AppointmentFile"> | number
    appointmentId?: IntWithAggregatesFilter<"AppointmentFile"> | number
    filename?: StringWithAggregatesFilter<"AppointmentFile"> | string
    mimeType?: StringNullableWithAggregatesFilter<"AppointmentFile"> | string | null
    filePath?: StringNullableWithAggregatesFilter<"AppointmentFile"> | string | null
  }

  export type StaffWhereInput = {
    AND?: StaffWhereInput | StaffWhereInput[]
    OR?: StaffWhereInput[]
    NOT?: StaffWhereInput | StaffWhereInput[]
    id?: IntFilter<"Staff"> | number
    userId?: IntFilter<"Staff"> | number
    name?: StringFilter<"Staff"> | string
    email?: StringNullableFilter<"Staff"> | string | null
    role?: StringFilter<"Staff"> | string
    phone?: StringNullableFilter<"Staff"> | string | null
    createdAt?: DateTimeFilter<"Staff"> | Date | string
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    appointments?: AppointmentListRelationFilter
    claims?: ClaimListRelationFilter
  }

  export type StaffOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    email?: SortOrderInput | SortOrder
    role?: SortOrder
    phone?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    appointments?: AppointmentOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
  }

  export type StaffWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: StaffWhereInput | StaffWhereInput[]
    OR?: StaffWhereInput[]
    NOT?: StaffWhereInput | StaffWhereInput[]
    userId?: IntFilter<"Staff"> | number
    name?: StringFilter<"Staff"> | string
    email?: StringNullableFilter<"Staff"> | string | null
    role?: StringFilter<"Staff"> | string
    phone?: StringNullableFilter<"Staff"> | string | null
    createdAt?: DateTimeFilter<"Staff"> | Date | string
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    appointments?: AppointmentListRelationFilter
    claims?: ClaimListRelationFilter
  }, "id">

  export type StaffOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    email?: SortOrderInput | SortOrder
    role?: SortOrder
    phone?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: StaffCountOrderByAggregateInput
    _avg?: StaffAvgOrderByAggregateInput
    _max?: StaffMaxOrderByAggregateInput
    _min?: StaffMinOrderByAggregateInput
    _sum?: StaffSumOrderByAggregateInput
  }

  export type StaffScalarWhereWithAggregatesInput = {
    AND?: StaffScalarWhereWithAggregatesInput | StaffScalarWhereWithAggregatesInput[]
    OR?: StaffScalarWhereWithAggregatesInput[]
    NOT?: StaffScalarWhereWithAggregatesInput | StaffScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Staff"> | number
    userId?: IntWithAggregatesFilter<"Staff"> | number
    name?: StringWithAggregatesFilter<"Staff"> | string
    email?: StringNullableWithAggregatesFilter<"Staff"> | string | null
    role?: StringWithAggregatesFilter<"Staff"> | string
    phone?: StringNullableWithAggregatesFilter<"Staff"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Staff"> | Date | string
  }

  export type NpiProviderWhereInput = {
    AND?: NpiProviderWhereInput | NpiProviderWhereInput[]
    OR?: NpiProviderWhereInput[]
    NOT?: NpiProviderWhereInput | NpiProviderWhereInput[]
    id?: IntFilter<"NpiProvider"> | number
    userId?: IntFilter<"NpiProvider"> | number
    npiNumber?: StringFilter<"NpiProvider"> | string
    providerName?: StringFilter<"NpiProvider"> | string
    createdAt?: DateTimeFilter<"NpiProvider"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    claims?: ClaimListRelationFilter
    payments?: PaymentListRelationFilter
    commissionBatches?: CommissionBatchListRelationFilter
    appointmentProcedures?: AppointmentProcedureListRelationFilter
  }

  export type NpiProviderOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    claims?: ClaimOrderByRelationAggregateInput
    payments?: PaymentOrderByRelationAggregateInput
    commissionBatches?: CommissionBatchOrderByRelationAggregateInput
    appointmentProcedures?: AppointmentProcedureOrderByRelationAggregateInput
  }

  export type NpiProviderWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId_npiNumber?: NpiProviderUserIdNpiNumberCompoundUniqueInput
    AND?: NpiProviderWhereInput | NpiProviderWhereInput[]
    OR?: NpiProviderWhereInput[]
    NOT?: NpiProviderWhereInput | NpiProviderWhereInput[]
    userId?: IntFilter<"NpiProvider"> | number
    npiNumber?: StringFilter<"NpiProvider"> | string
    providerName?: StringFilter<"NpiProvider"> | string
    createdAt?: DateTimeFilter<"NpiProvider"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    claims?: ClaimListRelationFilter
    payments?: PaymentListRelationFilter
    commissionBatches?: CommissionBatchListRelationFilter
    appointmentProcedures?: AppointmentProcedureListRelationFilter
  }, "id" | "userId_npiNumber">

  export type NpiProviderOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
    _count?: NpiProviderCountOrderByAggregateInput
    _avg?: NpiProviderAvgOrderByAggregateInput
    _max?: NpiProviderMaxOrderByAggregateInput
    _min?: NpiProviderMinOrderByAggregateInput
    _sum?: NpiProviderSumOrderByAggregateInput
  }

  export type NpiProviderScalarWhereWithAggregatesInput = {
    AND?: NpiProviderScalarWhereWithAggregatesInput | NpiProviderScalarWhereWithAggregatesInput[]
    OR?: NpiProviderScalarWhereWithAggregatesInput[]
    NOT?: NpiProviderScalarWhereWithAggregatesInput | NpiProviderScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"NpiProvider"> | number
    userId?: IntWithAggregatesFilter<"NpiProvider"> | number
    npiNumber?: StringWithAggregatesFilter<"NpiProvider"> | string
    providerName?: StringWithAggregatesFilter<"NpiProvider"> | string
    createdAt?: DateTimeWithAggregatesFilter<"NpiProvider"> | Date | string
  }

  export type AppointmentProcedureWhereInput = {
    AND?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    OR?: AppointmentProcedureWhereInput[]
    NOT?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    id?: IntFilter<"AppointmentProcedure"> | number
    appointmentId?: IntFilter<"AppointmentProcedure"> | number
    patientId?: IntFilter<"AppointmentProcedure"> | number
    npiProviderId?: IntNullableFilter<"AppointmentProcedure"> | number | null
    procedureCode?: StringFilter<"AppointmentProcedure"> | string
    procedureLabel?: StringNullableFilter<"AppointmentProcedure"> | string | null
    fee?: DecimalNullableFilter<"AppointmentProcedure"> | Decimal | DecimalJsLike | number | string | null
    category?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothNumber?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothSurface?: StringNullableFilter<"AppointmentProcedure"> | string | null
    oralCavityArea?: StringNullableFilter<"AppointmentProcedure"> | string | null
    source?: EnumProcedureSourceFilter<"AppointmentProcedure"> | $Enums.ProcedureSource
    comboKey?: StringNullableFilter<"AppointmentProcedure"> | string | null
    createdAt?: DateTimeFilter<"AppointmentProcedure"> | Date | string
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
  }

  export type AppointmentProcedureOrderByWithRelationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    procedureCode?: SortOrder
    procedureLabel?: SortOrderInput | SortOrder
    fee?: SortOrderInput | SortOrder
    category?: SortOrderInput | SortOrder
    toothNumber?: SortOrderInput | SortOrder
    toothSurface?: SortOrderInput | SortOrder
    oralCavityArea?: SortOrderInput | SortOrder
    source?: SortOrder
    comboKey?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    appointment?: AppointmentOrderByWithRelationInput
    patient?: PatientOrderByWithRelationInput
    npiProvider?: NpiProviderOrderByWithRelationInput
  }

  export type AppointmentProcedureWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    OR?: AppointmentProcedureWhereInput[]
    NOT?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    appointmentId?: IntFilter<"AppointmentProcedure"> | number
    patientId?: IntFilter<"AppointmentProcedure"> | number
    npiProviderId?: IntNullableFilter<"AppointmentProcedure"> | number | null
    procedureCode?: StringFilter<"AppointmentProcedure"> | string
    procedureLabel?: StringNullableFilter<"AppointmentProcedure"> | string | null
    fee?: DecimalNullableFilter<"AppointmentProcedure"> | Decimal | DecimalJsLike | number | string | null
    category?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothNumber?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothSurface?: StringNullableFilter<"AppointmentProcedure"> | string | null
    oralCavityArea?: StringNullableFilter<"AppointmentProcedure"> | string | null
    source?: EnumProcedureSourceFilter<"AppointmentProcedure"> | $Enums.ProcedureSource
    comboKey?: StringNullableFilter<"AppointmentProcedure"> | string | null
    createdAt?: DateTimeFilter<"AppointmentProcedure"> | Date | string
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
  }, "id">

  export type AppointmentProcedureOrderByWithAggregationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    procedureCode?: SortOrder
    procedureLabel?: SortOrderInput | SortOrder
    fee?: SortOrderInput | SortOrder
    category?: SortOrderInput | SortOrder
    toothNumber?: SortOrderInput | SortOrder
    toothSurface?: SortOrderInput | SortOrder
    oralCavityArea?: SortOrderInput | SortOrder
    source?: SortOrder
    comboKey?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: AppointmentProcedureCountOrderByAggregateInput
    _avg?: AppointmentProcedureAvgOrderByAggregateInput
    _max?: AppointmentProcedureMaxOrderByAggregateInput
    _min?: AppointmentProcedureMinOrderByAggregateInput
    _sum?: AppointmentProcedureSumOrderByAggregateInput
  }

  export type AppointmentProcedureScalarWhereWithAggregatesInput = {
    AND?: AppointmentProcedureScalarWhereWithAggregatesInput | AppointmentProcedureScalarWhereWithAggregatesInput[]
    OR?: AppointmentProcedureScalarWhereWithAggregatesInput[]
    NOT?: AppointmentProcedureScalarWhereWithAggregatesInput | AppointmentProcedureScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"AppointmentProcedure"> | number
    appointmentId?: IntWithAggregatesFilter<"AppointmentProcedure"> | number
    patientId?: IntWithAggregatesFilter<"AppointmentProcedure"> | number
    npiProviderId?: IntNullableWithAggregatesFilter<"AppointmentProcedure"> | number | null
    procedureCode?: StringWithAggregatesFilter<"AppointmentProcedure"> | string
    procedureLabel?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    fee?: DecimalNullableWithAggregatesFilter<"AppointmentProcedure"> | Decimal | DecimalJsLike | number | string | null
    category?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    toothNumber?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    toothSurface?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    oralCavityArea?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    source?: EnumProcedureSourceWithAggregatesFilter<"AppointmentProcedure"> | $Enums.ProcedureSource
    comboKey?: StringNullableWithAggregatesFilter<"AppointmentProcedure"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"AppointmentProcedure"> | Date | string
  }

  export type ClaimWhereInput = {
    AND?: ClaimWhereInput | ClaimWhereInput[]
    OR?: ClaimWhereInput[]
    NOT?: ClaimWhereInput | ClaimWhereInput[]
    id?: IntFilter<"Claim"> | number
    patientId?: IntFilter<"Claim"> | number
    appointmentId?: IntNullableFilter<"Claim"> | number | null
    userId?: IntFilter<"Claim"> | number
    staffId?: IntFilter<"Claim"> | number
    patientName?: StringFilter<"Claim"> | string
    memberId?: StringFilter<"Claim"> | string
    dateOfBirth?: DateTimeFilter<"Claim"> | Date | string
    remarks?: StringFilter<"Claim"> | string
    missingTeethStatus?: EnumMissingTeethStatusFilter<"Claim"> | $Enums.MissingTeethStatus
    missingTeeth?: JsonNullableFilter<"Claim">
    serviceDate?: DateTimeFilter<"Claim"> | Date | string
    insuranceProvider?: StringFilter<"Claim"> | string
    createdAt?: DateTimeFilter<"Claim"> | Date | string
    updatedAt?: DateTimeFilter<"Claim"> | Date | string
    status?: EnumClaimStatusFilter<"Claim"> | $Enums.ClaimStatus
    claimNumber?: StringNullableFilter<"Claim"> | string | null
    preAuthNumber?: StringNullableFilter<"Claim"> | string | null
    npiProviderId?: IntNullableFilter<"Claim"> | number | null
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    appointment?: XOR<AppointmentNullableScalarRelationFilter, AppointmentWhereInput> | null
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
    serviceLines?: ServiceLineListRelationFilter
    claimFiles?: ClaimFileListRelationFilter
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
  }

  export type ClaimOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrderInput | SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    patientName?: SortOrder
    memberId?: SortOrder
    dateOfBirth?: SortOrder
    remarks?: SortOrder
    missingTeethStatus?: SortOrder
    missingTeeth?: SortOrderInput | SortOrder
    serviceDate?: SortOrder
    insuranceProvider?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    status?: SortOrder
    claimNumber?: SortOrderInput | SortOrder
    preAuthNumber?: SortOrderInput | SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    patient?: PatientOrderByWithRelationInput
    appointment?: AppointmentOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    staff?: StaffOrderByWithRelationInput
    npiProvider?: NpiProviderOrderByWithRelationInput
    serviceLines?: ServiceLineOrderByRelationAggregateInput
    claimFiles?: ClaimFileOrderByRelationAggregateInput
    payment?: PaymentOrderByWithRelationInput
  }

  export type ClaimWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ClaimWhereInput | ClaimWhereInput[]
    OR?: ClaimWhereInput[]
    NOT?: ClaimWhereInput | ClaimWhereInput[]
    patientId?: IntFilter<"Claim"> | number
    appointmentId?: IntNullableFilter<"Claim"> | number | null
    userId?: IntFilter<"Claim"> | number
    staffId?: IntFilter<"Claim"> | number
    patientName?: StringFilter<"Claim"> | string
    memberId?: StringFilter<"Claim"> | string
    dateOfBirth?: DateTimeFilter<"Claim"> | Date | string
    remarks?: StringFilter<"Claim"> | string
    missingTeethStatus?: EnumMissingTeethStatusFilter<"Claim"> | $Enums.MissingTeethStatus
    missingTeeth?: JsonNullableFilter<"Claim">
    serviceDate?: DateTimeFilter<"Claim"> | Date | string
    insuranceProvider?: StringFilter<"Claim"> | string
    createdAt?: DateTimeFilter<"Claim"> | Date | string
    updatedAt?: DateTimeFilter<"Claim"> | Date | string
    status?: EnumClaimStatusFilter<"Claim"> | $Enums.ClaimStatus
    claimNumber?: StringNullableFilter<"Claim"> | string | null
    preAuthNumber?: StringNullableFilter<"Claim"> | string | null
    npiProviderId?: IntNullableFilter<"Claim"> | number | null
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    appointment?: XOR<AppointmentNullableScalarRelationFilter, AppointmentWhereInput> | null
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
    serviceLines?: ServiceLineListRelationFilter
    claimFiles?: ClaimFileListRelationFilter
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
  }, "id">

  export type ClaimOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrderInput | SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    patientName?: SortOrder
    memberId?: SortOrder
    dateOfBirth?: SortOrder
    remarks?: SortOrder
    missingTeethStatus?: SortOrder
    missingTeeth?: SortOrderInput | SortOrder
    serviceDate?: SortOrder
    insuranceProvider?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    status?: SortOrder
    claimNumber?: SortOrderInput | SortOrder
    preAuthNumber?: SortOrderInput | SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    _count?: ClaimCountOrderByAggregateInput
    _avg?: ClaimAvgOrderByAggregateInput
    _max?: ClaimMaxOrderByAggregateInput
    _min?: ClaimMinOrderByAggregateInput
    _sum?: ClaimSumOrderByAggregateInput
  }

  export type ClaimScalarWhereWithAggregatesInput = {
    AND?: ClaimScalarWhereWithAggregatesInput | ClaimScalarWhereWithAggregatesInput[]
    OR?: ClaimScalarWhereWithAggregatesInput[]
    NOT?: ClaimScalarWhereWithAggregatesInput | ClaimScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Claim"> | number
    patientId?: IntWithAggregatesFilter<"Claim"> | number
    appointmentId?: IntNullableWithAggregatesFilter<"Claim"> | number | null
    userId?: IntWithAggregatesFilter<"Claim"> | number
    staffId?: IntWithAggregatesFilter<"Claim"> | number
    patientName?: StringWithAggregatesFilter<"Claim"> | string
    memberId?: StringWithAggregatesFilter<"Claim"> | string
    dateOfBirth?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
    remarks?: StringWithAggregatesFilter<"Claim"> | string
    missingTeethStatus?: EnumMissingTeethStatusWithAggregatesFilter<"Claim"> | $Enums.MissingTeethStatus
    missingTeeth?: JsonNullableWithAggregatesFilter<"Claim">
    serviceDate?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
    insuranceProvider?: StringWithAggregatesFilter<"Claim"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
    status?: EnumClaimStatusWithAggregatesFilter<"Claim"> | $Enums.ClaimStatus
    claimNumber?: StringNullableWithAggregatesFilter<"Claim"> | string | null
    preAuthNumber?: StringNullableWithAggregatesFilter<"Claim"> | string | null
    npiProviderId?: IntNullableWithAggregatesFilter<"Claim"> | number | null
  }

  export type ServiceLineWhereInput = {
    AND?: ServiceLineWhereInput | ServiceLineWhereInput[]
    OR?: ServiceLineWhereInput[]
    NOT?: ServiceLineWhereInput | ServiceLineWhereInput[]
    id?: IntFilter<"ServiceLine"> | number
    claimId?: IntNullableFilter<"ServiceLine"> | number | null
    paymentId?: IntNullableFilter<"ServiceLine"> | number | null
    procedureCode?: StringFilter<"ServiceLine"> | string
    procedureDate?: DateTimeFilter<"ServiceLine"> | Date | string
    quad?: StringNullableFilter<"ServiceLine"> | string | null
    arch?: StringNullableFilter<"ServiceLine"> | string | null
    toothNumber?: StringNullableFilter<"ServiceLine"> | string | null
    toothSurface?: StringNullableFilter<"ServiceLine"> | string | null
    icn?: StringNullableFilter<"ServiceLine"> | string | null
    paidCode?: StringNullableFilter<"ServiceLine"> | string | null
    allowedAmount?: DecimalNullableFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFilter<"ServiceLine"> | $Enums.ServiceLineStatus
    claim?: XOR<ClaimNullableScalarRelationFilter, ClaimWhereInput> | null
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
  }

  export type ServiceLineOrderByWithRelationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    paymentId?: SortOrderInput | SortOrder
    procedureCode?: SortOrder
    procedureDate?: SortOrder
    quad?: SortOrderInput | SortOrder
    arch?: SortOrderInput | SortOrder
    toothNumber?: SortOrderInput | SortOrder
    toothSurface?: SortOrderInput | SortOrder
    icn?: SortOrderInput | SortOrder
    paidCode?: SortOrderInput | SortOrder
    allowedAmount?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    claim?: ClaimOrderByWithRelationInput
    payment?: PaymentOrderByWithRelationInput
    serviceLineTransactions?: ServiceLineTransactionOrderByRelationAggregateInput
  }

  export type ServiceLineWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ServiceLineWhereInput | ServiceLineWhereInput[]
    OR?: ServiceLineWhereInput[]
    NOT?: ServiceLineWhereInput | ServiceLineWhereInput[]
    claimId?: IntNullableFilter<"ServiceLine"> | number | null
    paymentId?: IntNullableFilter<"ServiceLine"> | number | null
    procedureCode?: StringFilter<"ServiceLine"> | string
    procedureDate?: DateTimeFilter<"ServiceLine"> | Date | string
    quad?: StringNullableFilter<"ServiceLine"> | string | null
    arch?: StringNullableFilter<"ServiceLine"> | string | null
    toothNumber?: StringNullableFilter<"ServiceLine"> | string | null
    toothSurface?: StringNullableFilter<"ServiceLine"> | string | null
    icn?: StringNullableFilter<"ServiceLine"> | string | null
    paidCode?: StringNullableFilter<"ServiceLine"> | string | null
    allowedAmount?: DecimalNullableFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFilter<"ServiceLine"> | $Enums.ServiceLineStatus
    claim?: XOR<ClaimNullableScalarRelationFilter, ClaimWhereInput> | null
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
  }, "id">

  export type ServiceLineOrderByWithAggregationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    paymentId?: SortOrderInput | SortOrder
    procedureCode?: SortOrder
    procedureDate?: SortOrder
    quad?: SortOrderInput | SortOrder
    arch?: SortOrderInput | SortOrder
    toothNumber?: SortOrderInput | SortOrder
    toothSurface?: SortOrderInput | SortOrder
    icn?: SortOrderInput | SortOrder
    paidCode?: SortOrderInput | SortOrder
    allowedAmount?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    _count?: ServiceLineCountOrderByAggregateInput
    _avg?: ServiceLineAvgOrderByAggregateInput
    _max?: ServiceLineMaxOrderByAggregateInput
    _min?: ServiceLineMinOrderByAggregateInput
    _sum?: ServiceLineSumOrderByAggregateInput
  }

  export type ServiceLineScalarWhereWithAggregatesInput = {
    AND?: ServiceLineScalarWhereWithAggregatesInput | ServiceLineScalarWhereWithAggregatesInput[]
    OR?: ServiceLineScalarWhereWithAggregatesInput[]
    NOT?: ServiceLineScalarWhereWithAggregatesInput | ServiceLineScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ServiceLine"> | number
    claimId?: IntNullableWithAggregatesFilter<"ServiceLine"> | number | null
    paymentId?: IntNullableWithAggregatesFilter<"ServiceLine"> | number | null
    procedureCode?: StringWithAggregatesFilter<"ServiceLine"> | string
    procedureDate?: DateTimeWithAggregatesFilter<"ServiceLine"> | Date | string
    quad?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    arch?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    toothNumber?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    toothSurface?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    icn?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    paidCode?: StringNullableWithAggregatesFilter<"ServiceLine"> | string | null
    allowedAmount?: DecimalNullableWithAggregatesFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalWithAggregatesFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalWithAggregatesFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalWithAggregatesFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalWithAggregatesFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusWithAggregatesFilter<"ServiceLine"> | $Enums.ServiceLineStatus
  }

  export type ClaimFileWhereInput = {
    AND?: ClaimFileWhereInput | ClaimFileWhereInput[]
    OR?: ClaimFileWhereInput[]
    NOT?: ClaimFileWhereInput | ClaimFileWhereInput[]
    id?: IntFilter<"ClaimFile"> | number
    claimId?: IntFilter<"ClaimFile"> | number
    filename?: StringFilter<"ClaimFile"> | string
    mimeType?: StringFilter<"ClaimFile"> | string
    filePath?: StringNullableFilter<"ClaimFile"> | string | null
    claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
  }

  export type ClaimFileOrderByWithRelationInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrderInput | SortOrder
    claim?: ClaimOrderByWithRelationInput
  }

  export type ClaimFileWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ClaimFileWhereInput | ClaimFileWhereInput[]
    OR?: ClaimFileWhereInput[]
    NOT?: ClaimFileWhereInput | ClaimFileWhereInput[]
    claimId?: IntFilter<"ClaimFile"> | number
    filename?: StringFilter<"ClaimFile"> | string
    mimeType?: StringFilter<"ClaimFile"> | string
    filePath?: StringNullableFilter<"ClaimFile"> | string | null
    claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
  }, "id">

  export type ClaimFileOrderByWithAggregationInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrderInput | SortOrder
    _count?: ClaimFileCountOrderByAggregateInput
    _avg?: ClaimFileAvgOrderByAggregateInput
    _max?: ClaimFileMaxOrderByAggregateInput
    _min?: ClaimFileMinOrderByAggregateInput
    _sum?: ClaimFileSumOrderByAggregateInput
  }

  export type ClaimFileScalarWhereWithAggregatesInput = {
    AND?: ClaimFileScalarWhereWithAggregatesInput | ClaimFileScalarWhereWithAggregatesInput[]
    OR?: ClaimFileScalarWhereWithAggregatesInput[]
    NOT?: ClaimFileScalarWhereWithAggregatesInput | ClaimFileScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ClaimFile"> | number
    claimId?: IntWithAggregatesFilter<"ClaimFile"> | number
    filename?: StringWithAggregatesFilter<"ClaimFile"> | string
    mimeType?: StringWithAggregatesFilter<"ClaimFile"> | string
    filePath?: StringNullableWithAggregatesFilter<"ClaimFile"> | string | null
  }

  export type InsuranceCredentialWhereInput = {
    AND?: InsuranceCredentialWhereInput | InsuranceCredentialWhereInput[]
    OR?: InsuranceCredentialWhereInput[]
    NOT?: InsuranceCredentialWhereInput | InsuranceCredentialWhereInput[]
    id?: IntFilter<"InsuranceCredential"> | number
    userId?: IntFilter<"InsuranceCredential"> | number
    siteKey?: StringFilter<"InsuranceCredential"> | string
    username?: StringFilter<"InsuranceCredential"> | string
    password?: StringFilter<"InsuranceCredential"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type InsuranceCredentialOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    siteKey?: SortOrder
    username?: SortOrder
    password?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type InsuranceCredentialWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId_siteKey?: InsuranceCredentialUserIdSiteKeyCompoundUniqueInput
    AND?: InsuranceCredentialWhereInput | InsuranceCredentialWhereInput[]
    OR?: InsuranceCredentialWhereInput[]
    NOT?: InsuranceCredentialWhereInput | InsuranceCredentialWhereInput[]
    userId?: IntFilter<"InsuranceCredential"> | number
    siteKey?: StringFilter<"InsuranceCredential"> | string
    username?: StringFilter<"InsuranceCredential"> | string
    password?: StringFilter<"InsuranceCredential"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId_siteKey">

  export type InsuranceCredentialOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    siteKey?: SortOrder
    username?: SortOrder
    password?: SortOrder
    _count?: InsuranceCredentialCountOrderByAggregateInput
    _avg?: InsuranceCredentialAvgOrderByAggregateInput
    _max?: InsuranceCredentialMaxOrderByAggregateInput
    _min?: InsuranceCredentialMinOrderByAggregateInput
    _sum?: InsuranceCredentialSumOrderByAggregateInput
  }

  export type InsuranceCredentialScalarWhereWithAggregatesInput = {
    AND?: InsuranceCredentialScalarWhereWithAggregatesInput | InsuranceCredentialScalarWhereWithAggregatesInput[]
    OR?: InsuranceCredentialScalarWhereWithAggregatesInput[]
    NOT?: InsuranceCredentialScalarWhereWithAggregatesInput | InsuranceCredentialScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"InsuranceCredential"> | number
    userId?: IntWithAggregatesFilter<"InsuranceCredential"> | number
    siteKey?: StringWithAggregatesFilter<"InsuranceCredential"> | string
    username?: StringWithAggregatesFilter<"InsuranceCredential"> | string
    password?: StringWithAggregatesFilter<"InsuranceCredential"> | string
  }

  export type ShoppingVendorWhereInput = {
    AND?: ShoppingVendorWhereInput | ShoppingVendorWhereInput[]
    OR?: ShoppingVendorWhereInput[]
    NOT?: ShoppingVendorWhereInput | ShoppingVendorWhereInput[]
    id?: IntFilter<"ShoppingVendor"> | number
    userId?: IntFilter<"ShoppingVendor"> | number
    vendorName?: StringFilter<"ShoppingVendor"> | string
    websiteUrl?: StringFilter<"ShoppingVendor"> | string
    loginUsername?: StringFilter<"ShoppingVendor"> | string
    loginPassword?: StringFilter<"ShoppingVendor"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type ShoppingVendorOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    vendorName?: SortOrder
    websiteUrl?: SortOrder
    loginUsername?: SortOrder
    loginPassword?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type ShoppingVendorWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ShoppingVendorWhereInput | ShoppingVendorWhereInput[]
    OR?: ShoppingVendorWhereInput[]
    NOT?: ShoppingVendorWhereInput | ShoppingVendorWhereInput[]
    userId?: IntFilter<"ShoppingVendor"> | number
    vendorName?: StringFilter<"ShoppingVendor"> | string
    websiteUrl?: StringFilter<"ShoppingVendor"> | string
    loginUsername?: StringFilter<"ShoppingVendor"> | string
    loginPassword?: StringFilter<"ShoppingVendor"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type ShoppingVendorOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    vendorName?: SortOrder
    websiteUrl?: SortOrder
    loginUsername?: SortOrder
    loginPassword?: SortOrder
    _count?: ShoppingVendorCountOrderByAggregateInput
    _avg?: ShoppingVendorAvgOrderByAggregateInput
    _max?: ShoppingVendorMaxOrderByAggregateInput
    _min?: ShoppingVendorMinOrderByAggregateInput
    _sum?: ShoppingVendorSumOrderByAggregateInput
  }

  export type ShoppingVendorScalarWhereWithAggregatesInput = {
    AND?: ShoppingVendorScalarWhereWithAggregatesInput | ShoppingVendorScalarWhereWithAggregatesInput[]
    OR?: ShoppingVendorScalarWhereWithAggregatesInput[]
    NOT?: ShoppingVendorScalarWhereWithAggregatesInput | ShoppingVendorScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ShoppingVendor"> | number
    userId?: IntWithAggregatesFilter<"ShoppingVendor"> | number
    vendorName?: StringWithAggregatesFilter<"ShoppingVendor"> | string
    websiteUrl?: StringWithAggregatesFilter<"ShoppingVendor"> | string
    loginUsername?: StringWithAggregatesFilter<"ShoppingVendor"> | string
    loginPassword?: StringWithAggregatesFilter<"ShoppingVendor"> | string
  }

  export type PdfGroupWhereInput = {
    AND?: PdfGroupWhereInput | PdfGroupWhereInput[]
    OR?: PdfGroupWhereInput[]
    NOT?: PdfGroupWhereInput | PdfGroupWhereInput[]
    id?: IntFilter<"PdfGroup"> | number
    title?: StringFilter<"PdfGroup"> | string
    titleKey?: EnumPdfTitleKeyFilter<"PdfGroup"> | $Enums.PdfTitleKey
    createdAt?: DateTimeFilter<"PdfGroup"> | Date | string
    patientId?: IntFilter<"PdfGroup"> | number
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    pdfs?: PdfFileListRelationFilter
  }

  export type PdfGroupOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    titleKey?: SortOrder
    createdAt?: SortOrder
    patientId?: SortOrder
    patient?: PatientOrderByWithRelationInput
    pdfs?: PdfFileOrderByRelationAggregateInput
  }

  export type PdfGroupWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PdfGroupWhereInput | PdfGroupWhereInput[]
    OR?: PdfGroupWhereInput[]
    NOT?: PdfGroupWhereInput | PdfGroupWhereInput[]
    title?: StringFilter<"PdfGroup"> | string
    titleKey?: EnumPdfTitleKeyFilter<"PdfGroup"> | $Enums.PdfTitleKey
    createdAt?: DateTimeFilter<"PdfGroup"> | Date | string
    patientId?: IntFilter<"PdfGroup"> | number
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    pdfs?: PdfFileListRelationFilter
  }, "id">

  export type PdfGroupOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    titleKey?: SortOrder
    createdAt?: SortOrder
    patientId?: SortOrder
    _count?: PdfGroupCountOrderByAggregateInput
    _avg?: PdfGroupAvgOrderByAggregateInput
    _max?: PdfGroupMaxOrderByAggregateInput
    _min?: PdfGroupMinOrderByAggregateInput
    _sum?: PdfGroupSumOrderByAggregateInput
  }

  export type PdfGroupScalarWhereWithAggregatesInput = {
    AND?: PdfGroupScalarWhereWithAggregatesInput | PdfGroupScalarWhereWithAggregatesInput[]
    OR?: PdfGroupScalarWhereWithAggregatesInput[]
    NOT?: PdfGroupScalarWhereWithAggregatesInput | PdfGroupScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PdfGroup"> | number
    title?: StringWithAggregatesFilter<"PdfGroup"> | string
    titleKey?: EnumPdfTitleKeyWithAggregatesFilter<"PdfGroup"> | $Enums.PdfTitleKey
    createdAt?: DateTimeWithAggregatesFilter<"PdfGroup"> | Date | string
    patientId?: IntWithAggregatesFilter<"PdfGroup"> | number
  }

  export type PdfFileWhereInput = {
    AND?: PdfFileWhereInput | PdfFileWhereInput[]
    OR?: PdfFileWhereInput[]
    NOT?: PdfFileWhereInput | PdfFileWhereInput[]
    id?: IntFilter<"PdfFile"> | number
    filename?: StringFilter<"PdfFile"> | string
    pdfData?: BytesFilter<"PdfFile"> | Bytes
    uploadedAt?: DateTimeFilter<"PdfFile"> | Date | string
    groupId?: IntFilter<"PdfFile"> | number
    group?: XOR<PdfGroupScalarRelationFilter, PdfGroupWhereInput>
  }

  export type PdfFileOrderByWithRelationInput = {
    id?: SortOrder
    filename?: SortOrder
    pdfData?: SortOrder
    uploadedAt?: SortOrder
    groupId?: SortOrder
    group?: PdfGroupOrderByWithRelationInput
  }

  export type PdfFileWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PdfFileWhereInput | PdfFileWhereInput[]
    OR?: PdfFileWhereInput[]
    NOT?: PdfFileWhereInput | PdfFileWhereInput[]
    filename?: StringFilter<"PdfFile"> | string
    pdfData?: BytesFilter<"PdfFile"> | Bytes
    uploadedAt?: DateTimeFilter<"PdfFile"> | Date | string
    groupId?: IntFilter<"PdfFile"> | number
    group?: XOR<PdfGroupScalarRelationFilter, PdfGroupWhereInput>
  }, "id">

  export type PdfFileOrderByWithAggregationInput = {
    id?: SortOrder
    filename?: SortOrder
    pdfData?: SortOrder
    uploadedAt?: SortOrder
    groupId?: SortOrder
    _count?: PdfFileCountOrderByAggregateInput
    _avg?: PdfFileAvgOrderByAggregateInput
    _max?: PdfFileMaxOrderByAggregateInput
    _min?: PdfFileMinOrderByAggregateInput
    _sum?: PdfFileSumOrderByAggregateInput
  }

  export type PdfFileScalarWhereWithAggregatesInput = {
    AND?: PdfFileScalarWhereWithAggregatesInput | PdfFileScalarWhereWithAggregatesInput[]
    OR?: PdfFileScalarWhereWithAggregatesInput[]
    NOT?: PdfFileScalarWhereWithAggregatesInput | PdfFileScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PdfFile"> | number
    filename?: StringWithAggregatesFilter<"PdfFile"> | string
    pdfData?: BytesWithAggregatesFilter<"PdfFile"> | Bytes
    uploadedAt?: DateTimeWithAggregatesFilter<"PdfFile"> | Date | string
    groupId?: IntWithAggregatesFilter<"PdfFile"> | number
  }

  export type PaymentWhereInput = {
    AND?: PaymentWhereInput | PaymentWhereInput[]
    OR?: PaymentWhereInput[]
    NOT?: PaymentWhereInput | PaymentWhereInput[]
    id?: IntFilter<"Payment"> | number
    claimId?: IntNullableFilter<"Payment"> | number | null
    patientId?: IntFilter<"Payment"> | number
    userId?: IntFilter<"Payment"> | number
    updatedById?: IntNullableFilter<"Payment"> | number | null
    npiProviderId?: IntNullableFilter<"Payment"> | number | null
    totalBilled?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: DecimalNullableFilter<"Payment"> | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    notes?: StringNullableFilter<"Payment"> | string | null
    icn?: StringNullableFilter<"Payment"> | string | null
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
    claim?: XOR<ClaimNullableScalarRelationFilter, ClaimWhereInput> | null
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    updatedBy?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
    serviceLines?: ServiceLineListRelationFilter
    commissionBatchItems?: CommissionBatchItemListRelationFilter
  }

  export type PaymentOrderByWithRelationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrderInput | SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrderInput | SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
    status?: SortOrder
    notes?: SortOrderInput | SortOrder
    icn?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    claim?: ClaimOrderByWithRelationInput
    patient?: PatientOrderByWithRelationInput
    updatedBy?: UserOrderByWithRelationInput
    npiProvider?: NpiProviderOrderByWithRelationInput
    serviceLineTransactions?: ServiceLineTransactionOrderByRelationAggregateInput
    serviceLines?: ServiceLineOrderByRelationAggregateInput
    commissionBatchItems?: CommissionBatchItemOrderByRelationAggregateInput
  }

  export type PaymentWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    claimId?: number
    AND?: PaymentWhereInput | PaymentWhereInput[]
    OR?: PaymentWhereInput[]
    NOT?: PaymentWhereInput | PaymentWhereInput[]
    patientId?: IntFilter<"Payment"> | number
    userId?: IntFilter<"Payment"> | number
    updatedById?: IntNullableFilter<"Payment"> | number | null
    npiProviderId?: IntNullableFilter<"Payment"> | number | null
    totalBilled?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: DecimalNullableFilter<"Payment"> | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    notes?: StringNullableFilter<"Payment"> | string | null
    icn?: StringNullableFilter<"Payment"> | string | null
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
    claim?: XOR<ClaimNullableScalarRelationFilter, ClaimWhereInput> | null
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    updatedBy?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    npiProvider?: XOR<NpiProviderNullableScalarRelationFilter, NpiProviderWhereInput> | null
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
    serviceLines?: ServiceLineListRelationFilter
    commissionBatchItems?: CommissionBatchItemListRelationFilter
  }, "id" | "claimId">

  export type PaymentOrderByWithAggregationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrderInput | SortOrder
    npiProviderId?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrderInput | SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
    status?: SortOrder
    notes?: SortOrderInput | SortOrder
    icn?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PaymentCountOrderByAggregateInput
    _avg?: PaymentAvgOrderByAggregateInput
    _max?: PaymentMaxOrderByAggregateInput
    _min?: PaymentMinOrderByAggregateInput
    _sum?: PaymentSumOrderByAggregateInput
  }

  export type PaymentScalarWhereWithAggregatesInput = {
    AND?: PaymentScalarWhereWithAggregatesInput | PaymentScalarWhereWithAggregatesInput[]
    OR?: PaymentScalarWhereWithAggregatesInput[]
    NOT?: PaymentScalarWhereWithAggregatesInput | PaymentScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Payment"> | number
    claimId?: IntNullableWithAggregatesFilter<"Payment"> | number | null
    patientId?: IntWithAggregatesFilter<"Payment"> | number
    userId?: IntWithAggregatesFilter<"Payment"> | number
    updatedById?: IntNullableWithAggregatesFilter<"Payment"> | number | null
    npiProviderId?: IntNullableWithAggregatesFilter<"Payment"> | number | null
    totalBilled?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: DecimalNullableWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalWithAggregatesFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusWithAggregatesFilter<"Payment"> | $Enums.PaymentStatus
    notes?: StringNullableWithAggregatesFilter<"Payment"> | string | null
    icn?: StringNullableWithAggregatesFilter<"Payment"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Payment"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Payment"> | Date | string
  }

  export type ServiceLineTransactionWhereInput = {
    AND?: ServiceLineTransactionWhereInput | ServiceLineTransactionWhereInput[]
    OR?: ServiceLineTransactionWhereInput[]
    NOT?: ServiceLineTransactionWhereInput | ServiceLineTransactionWhereInput[]
    id?: IntFilter<"ServiceLineTransaction"> | number
    paymentId?: IntFilter<"ServiceLineTransaction"> | number
    serviceLineId?: IntFilter<"ServiceLineTransaction"> | number
    transactionId?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    paidAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFilter<"ServiceLineTransaction"> | $Enums.PaymentMethod
    receivedDate?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
    payerName?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    notes?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    createdAt?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
    payment?: XOR<PaymentScalarRelationFilter, PaymentWhereInput>
    serviceLine?: XOR<ServiceLineScalarRelationFilter, ServiceLineWhereInput>
  }

  export type ServiceLineTransactionOrderByWithRelationInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    transactionId?: SortOrderInput | SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
    method?: SortOrder
    receivedDate?: SortOrder
    payerName?: SortOrderInput | SortOrder
    notes?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    payment?: PaymentOrderByWithRelationInput
    serviceLine?: ServiceLineOrderByWithRelationInput
  }

  export type ServiceLineTransactionWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ServiceLineTransactionWhereInput | ServiceLineTransactionWhereInput[]
    OR?: ServiceLineTransactionWhereInput[]
    NOT?: ServiceLineTransactionWhereInput | ServiceLineTransactionWhereInput[]
    paymentId?: IntFilter<"ServiceLineTransaction"> | number
    serviceLineId?: IntFilter<"ServiceLineTransaction"> | number
    transactionId?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    paidAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFilter<"ServiceLineTransaction"> | $Enums.PaymentMethod
    receivedDate?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
    payerName?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    notes?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    createdAt?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
    payment?: XOR<PaymentScalarRelationFilter, PaymentWhereInput>
    serviceLine?: XOR<ServiceLineScalarRelationFilter, ServiceLineWhereInput>
  }, "id">

  export type ServiceLineTransactionOrderByWithAggregationInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    transactionId?: SortOrderInput | SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
    method?: SortOrder
    receivedDate?: SortOrder
    payerName?: SortOrderInput | SortOrder
    notes?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: ServiceLineTransactionCountOrderByAggregateInput
    _avg?: ServiceLineTransactionAvgOrderByAggregateInput
    _max?: ServiceLineTransactionMaxOrderByAggregateInput
    _min?: ServiceLineTransactionMinOrderByAggregateInput
    _sum?: ServiceLineTransactionSumOrderByAggregateInput
  }

  export type ServiceLineTransactionScalarWhereWithAggregatesInput = {
    AND?: ServiceLineTransactionScalarWhereWithAggregatesInput | ServiceLineTransactionScalarWhereWithAggregatesInput[]
    OR?: ServiceLineTransactionScalarWhereWithAggregatesInput[]
    NOT?: ServiceLineTransactionScalarWhereWithAggregatesInput | ServiceLineTransactionScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ServiceLineTransaction"> | number
    paymentId?: IntWithAggregatesFilter<"ServiceLineTransaction"> | number
    serviceLineId?: IntWithAggregatesFilter<"ServiceLineTransaction"> | number
    transactionId?: StringNullableWithAggregatesFilter<"ServiceLineTransaction"> | string | null
    paidAmount?: DecimalWithAggregatesFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalWithAggregatesFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodWithAggregatesFilter<"ServiceLineTransaction"> | $Enums.PaymentMethod
    receivedDate?: DateTimeWithAggregatesFilter<"ServiceLineTransaction"> | Date | string
    payerName?: StringNullableWithAggregatesFilter<"ServiceLineTransaction"> | string | null
    notes?: StringNullableWithAggregatesFilter<"ServiceLineTransaction"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"ServiceLineTransaction"> | Date | string
  }

  export type DatabaseBackupWhereInput = {
    AND?: DatabaseBackupWhereInput | DatabaseBackupWhereInput[]
    OR?: DatabaseBackupWhereInput[]
    NOT?: DatabaseBackupWhereInput | DatabaseBackupWhereInput[]
    id?: IntFilter<"DatabaseBackup"> | number
    userId?: IntFilter<"DatabaseBackup"> | number
    createdAt?: DateTimeFilter<"DatabaseBackup"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type DatabaseBackupOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type DatabaseBackupWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: DatabaseBackupWhereInput | DatabaseBackupWhereInput[]
    OR?: DatabaseBackupWhereInput[]
    NOT?: DatabaseBackupWhereInput | DatabaseBackupWhereInput[]
    userId?: IntFilter<"DatabaseBackup"> | number
    createdAt?: DateTimeFilter<"DatabaseBackup"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type DatabaseBackupOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    _count?: DatabaseBackupCountOrderByAggregateInput
    _avg?: DatabaseBackupAvgOrderByAggregateInput
    _max?: DatabaseBackupMaxOrderByAggregateInput
    _min?: DatabaseBackupMinOrderByAggregateInput
    _sum?: DatabaseBackupSumOrderByAggregateInput
  }

  export type DatabaseBackupScalarWhereWithAggregatesInput = {
    AND?: DatabaseBackupScalarWhereWithAggregatesInput | DatabaseBackupScalarWhereWithAggregatesInput[]
    OR?: DatabaseBackupScalarWhereWithAggregatesInput[]
    NOT?: DatabaseBackupScalarWhereWithAggregatesInput | DatabaseBackupScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"DatabaseBackup"> | number
    userId?: IntWithAggregatesFilter<"DatabaseBackup"> | number
    createdAt?: DateTimeWithAggregatesFilter<"DatabaseBackup"> | Date | string
  }

  export type BackupDestinationWhereInput = {
    AND?: BackupDestinationWhereInput | BackupDestinationWhereInput[]
    OR?: BackupDestinationWhereInput[]
    NOT?: BackupDestinationWhereInput | BackupDestinationWhereInput[]
    id?: IntFilter<"BackupDestination"> | number
    userId?: IntFilter<"BackupDestination"> | number
    path?: StringFilter<"BackupDestination"> | string
    isActive?: BoolFilter<"BackupDestination"> | boolean
    createdAt?: DateTimeFilter<"BackupDestination"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type BackupDestinationOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    path?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type BackupDestinationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: BackupDestinationWhereInput | BackupDestinationWhereInput[]
    OR?: BackupDestinationWhereInput[]
    NOT?: BackupDestinationWhereInput | BackupDestinationWhereInput[]
    userId?: IntFilter<"BackupDestination"> | number
    path?: StringFilter<"BackupDestination"> | string
    isActive?: BoolFilter<"BackupDestination"> | boolean
    createdAt?: DateTimeFilter<"BackupDestination"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type BackupDestinationOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    path?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    _count?: BackupDestinationCountOrderByAggregateInput
    _avg?: BackupDestinationAvgOrderByAggregateInput
    _max?: BackupDestinationMaxOrderByAggregateInput
    _min?: BackupDestinationMinOrderByAggregateInput
    _sum?: BackupDestinationSumOrderByAggregateInput
  }

  export type BackupDestinationScalarWhereWithAggregatesInput = {
    AND?: BackupDestinationScalarWhereWithAggregatesInput | BackupDestinationScalarWhereWithAggregatesInput[]
    OR?: BackupDestinationScalarWhereWithAggregatesInput[]
    NOT?: BackupDestinationScalarWhereWithAggregatesInput | BackupDestinationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"BackupDestination"> | number
    userId?: IntWithAggregatesFilter<"BackupDestination"> | number
    path?: StringWithAggregatesFilter<"BackupDestination"> | string
    isActive?: BoolWithAggregatesFilter<"BackupDestination"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"BackupDestination"> | Date | string
  }

  export type NotificationWhereInput = {
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    id?: IntFilter<"Notification"> | number
    userId?: IntFilter<"Notification"> | number
    type?: EnumNotificationTypesFilter<"Notification"> | $Enums.NotificationTypes
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    read?: BoolFilter<"Notification"> | boolean
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type NotificationOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    read?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type NotificationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    userId?: IntFilter<"Notification"> | number
    type?: EnumNotificationTypesFilter<"Notification"> | $Enums.NotificationTypes
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    read?: BoolFilter<"Notification"> | boolean
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type NotificationOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    read?: SortOrder
    _count?: NotificationCountOrderByAggregateInput
    _avg?: NotificationAvgOrderByAggregateInput
    _max?: NotificationMaxOrderByAggregateInput
    _min?: NotificationMinOrderByAggregateInput
    _sum?: NotificationSumOrderByAggregateInput
  }

  export type NotificationScalarWhereWithAggregatesInput = {
    AND?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    OR?: NotificationScalarWhereWithAggregatesInput[]
    NOT?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Notification"> | number
    userId?: IntWithAggregatesFilter<"Notification"> | number
    type?: EnumNotificationTypesWithAggregatesFilter<"Notification"> | $Enums.NotificationTypes
    message?: StringWithAggregatesFilter<"Notification"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Notification"> | Date | string
    read?: BoolWithAggregatesFilter<"Notification"> | boolean
  }

  export type CronJobLogWhereInput = {
    AND?: CronJobLogWhereInput | CronJobLogWhereInput[]
    OR?: CronJobLogWhereInput[]
    NOT?: CronJobLogWhereInput | CronJobLogWhereInput[]
    id?: IntFilter<"CronJobLog"> | number
    jobName?: StringFilter<"CronJobLog"> | string
    status?: StringFilter<"CronJobLog"> | string
    startedAt?: DateTimeFilter<"CronJobLog"> | Date | string
    completedAt?: DateTimeNullableFilter<"CronJobLog"> | Date | string | null
    durationMs?: IntNullableFilter<"CronJobLog"> | number | null
    errorMessage?: StringNullableFilter<"CronJobLog"> | string | null
  }

  export type CronJobLogOrderByWithRelationInput = {
    id?: SortOrder
    jobName?: SortOrder
    status?: SortOrder
    startedAt?: SortOrder
    completedAt?: SortOrderInput | SortOrder
    durationMs?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
  }

  export type CronJobLogWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CronJobLogWhereInput | CronJobLogWhereInput[]
    OR?: CronJobLogWhereInput[]
    NOT?: CronJobLogWhereInput | CronJobLogWhereInput[]
    jobName?: StringFilter<"CronJobLog"> | string
    status?: StringFilter<"CronJobLog"> | string
    startedAt?: DateTimeFilter<"CronJobLog"> | Date | string
    completedAt?: DateTimeNullableFilter<"CronJobLog"> | Date | string | null
    durationMs?: IntNullableFilter<"CronJobLog"> | number | null
    errorMessage?: StringNullableFilter<"CronJobLog"> | string | null
  }, "id">

  export type CronJobLogOrderByWithAggregationInput = {
    id?: SortOrder
    jobName?: SortOrder
    status?: SortOrder
    startedAt?: SortOrder
    completedAt?: SortOrderInput | SortOrder
    durationMs?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
    _count?: CronJobLogCountOrderByAggregateInput
    _avg?: CronJobLogAvgOrderByAggregateInput
    _max?: CronJobLogMaxOrderByAggregateInput
    _min?: CronJobLogMinOrderByAggregateInput
    _sum?: CronJobLogSumOrderByAggregateInput
  }

  export type CronJobLogScalarWhereWithAggregatesInput = {
    AND?: CronJobLogScalarWhereWithAggregatesInput | CronJobLogScalarWhereWithAggregatesInput[]
    OR?: CronJobLogScalarWhereWithAggregatesInput[]
    NOT?: CronJobLogScalarWhereWithAggregatesInput | CronJobLogScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CronJobLog"> | number
    jobName?: StringWithAggregatesFilter<"CronJobLog"> | string
    status?: StringWithAggregatesFilter<"CronJobLog"> | string
    startedAt?: DateTimeWithAggregatesFilter<"CronJobLog"> | Date | string
    completedAt?: DateTimeNullableWithAggregatesFilter<"CronJobLog"> | Date | string | null
    durationMs?: IntNullableWithAggregatesFilter<"CronJobLog"> | number | null
    errorMessage?: StringNullableWithAggregatesFilter<"CronJobLog"> | string | null
  }

  export type CloudFolderWhereInput = {
    AND?: CloudFolderWhereInput | CloudFolderWhereInput[]
    OR?: CloudFolderWhereInput[]
    NOT?: CloudFolderWhereInput | CloudFolderWhereInput[]
    id?: IntFilter<"CloudFolder"> | number
    userId?: IntFilter<"CloudFolder"> | number
    name?: StringFilter<"CloudFolder"> | string
    parentId?: IntNullableFilter<"CloudFolder"> | number | null
    createdAt?: DateTimeFilter<"CloudFolder"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFolder"> | Date | string
    parent?: XOR<CloudFolderNullableScalarRelationFilter, CloudFolderWhereInput> | null
    children?: CloudFolderListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    files?: CloudFileListRelationFilter
  }

  export type CloudFolderOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    parentId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    parent?: CloudFolderOrderByWithRelationInput
    children?: CloudFolderOrderByRelationAggregateInput
    user?: UserOrderByWithRelationInput
    files?: CloudFileOrderByRelationAggregateInput
  }

  export type CloudFolderWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId_parentId_name?: CloudFolderUserIdParentIdNameCompoundUniqueInput
    AND?: CloudFolderWhereInput | CloudFolderWhereInput[]
    OR?: CloudFolderWhereInput[]
    NOT?: CloudFolderWhereInput | CloudFolderWhereInput[]
    userId?: IntFilter<"CloudFolder"> | number
    name?: StringFilter<"CloudFolder"> | string
    parentId?: IntNullableFilter<"CloudFolder"> | number | null
    createdAt?: DateTimeFilter<"CloudFolder"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFolder"> | Date | string
    parent?: XOR<CloudFolderNullableScalarRelationFilter, CloudFolderWhereInput> | null
    children?: CloudFolderListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    files?: CloudFileListRelationFilter
  }, "id" | "userId_parentId_name">

  export type CloudFolderOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    parentId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: CloudFolderCountOrderByAggregateInput
    _avg?: CloudFolderAvgOrderByAggregateInput
    _max?: CloudFolderMaxOrderByAggregateInput
    _min?: CloudFolderMinOrderByAggregateInput
    _sum?: CloudFolderSumOrderByAggregateInput
  }

  export type CloudFolderScalarWhereWithAggregatesInput = {
    AND?: CloudFolderScalarWhereWithAggregatesInput | CloudFolderScalarWhereWithAggregatesInput[]
    OR?: CloudFolderScalarWhereWithAggregatesInput[]
    NOT?: CloudFolderScalarWhereWithAggregatesInput | CloudFolderScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CloudFolder"> | number
    userId?: IntWithAggregatesFilter<"CloudFolder"> | number
    name?: StringWithAggregatesFilter<"CloudFolder"> | string
    parentId?: IntNullableWithAggregatesFilter<"CloudFolder"> | number | null
    createdAt?: DateTimeWithAggregatesFilter<"CloudFolder"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"CloudFolder"> | Date | string
  }

  export type CloudFileWhereInput = {
    AND?: CloudFileWhereInput | CloudFileWhereInput[]
    OR?: CloudFileWhereInput[]
    NOT?: CloudFileWhereInput | CloudFileWhereInput[]
    id?: IntFilter<"CloudFile"> | number
    userId?: IntFilter<"CloudFile"> | number
    name?: StringFilter<"CloudFile"> | string
    mimeType?: StringNullableFilter<"CloudFile"> | string | null
    fileSize?: BigIntFilter<"CloudFile"> | bigint | number
    folderId?: IntNullableFilter<"CloudFile"> | number | null
    isComplete?: BoolFilter<"CloudFile"> | boolean
    totalChunks?: IntNullableFilter<"CloudFile"> | number | null
    diskPath?: StringNullableFilter<"CloudFile"> | string | null
    createdAt?: DateTimeFilter<"CloudFile"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFile"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    folder?: XOR<CloudFolderNullableScalarRelationFilter, CloudFolderWhereInput> | null
    chunks?: CloudFileChunkListRelationFilter
  }

  export type CloudFileOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrderInput | SortOrder
    fileSize?: SortOrder
    folderId?: SortOrderInput | SortOrder
    isComplete?: SortOrder
    totalChunks?: SortOrderInput | SortOrder
    diskPath?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    folder?: CloudFolderOrderByWithRelationInput
    chunks?: CloudFileChunkOrderByRelationAggregateInput
  }

  export type CloudFileWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CloudFileWhereInput | CloudFileWhereInput[]
    OR?: CloudFileWhereInput[]
    NOT?: CloudFileWhereInput | CloudFileWhereInput[]
    userId?: IntFilter<"CloudFile"> | number
    name?: StringFilter<"CloudFile"> | string
    mimeType?: StringNullableFilter<"CloudFile"> | string | null
    fileSize?: BigIntFilter<"CloudFile"> | bigint | number
    folderId?: IntNullableFilter<"CloudFile"> | number | null
    isComplete?: BoolFilter<"CloudFile"> | boolean
    totalChunks?: IntNullableFilter<"CloudFile"> | number | null
    diskPath?: StringNullableFilter<"CloudFile"> | string | null
    createdAt?: DateTimeFilter<"CloudFile"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFile"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    folder?: XOR<CloudFolderNullableScalarRelationFilter, CloudFolderWhereInput> | null
    chunks?: CloudFileChunkListRelationFilter
  }, "id">

  export type CloudFileOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrderInput | SortOrder
    fileSize?: SortOrder
    folderId?: SortOrderInput | SortOrder
    isComplete?: SortOrder
    totalChunks?: SortOrderInput | SortOrder
    diskPath?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: CloudFileCountOrderByAggregateInput
    _avg?: CloudFileAvgOrderByAggregateInput
    _max?: CloudFileMaxOrderByAggregateInput
    _min?: CloudFileMinOrderByAggregateInput
    _sum?: CloudFileSumOrderByAggregateInput
  }

  export type CloudFileScalarWhereWithAggregatesInput = {
    AND?: CloudFileScalarWhereWithAggregatesInput | CloudFileScalarWhereWithAggregatesInput[]
    OR?: CloudFileScalarWhereWithAggregatesInput[]
    NOT?: CloudFileScalarWhereWithAggregatesInput | CloudFileScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CloudFile"> | number
    userId?: IntWithAggregatesFilter<"CloudFile"> | number
    name?: StringWithAggregatesFilter<"CloudFile"> | string
    mimeType?: StringNullableWithAggregatesFilter<"CloudFile"> | string | null
    fileSize?: BigIntWithAggregatesFilter<"CloudFile"> | bigint | number
    folderId?: IntNullableWithAggregatesFilter<"CloudFile"> | number | null
    isComplete?: BoolWithAggregatesFilter<"CloudFile"> | boolean
    totalChunks?: IntNullableWithAggregatesFilter<"CloudFile"> | number | null
    diskPath?: StringNullableWithAggregatesFilter<"CloudFile"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"CloudFile"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"CloudFile"> | Date | string
  }

  export type CloudFileChunkWhereInput = {
    AND?: CloudFileChunkWhereInput | CloudFileChunkWhereInput[]
    OR?: CloudFileChunkWhereInput[]
    NOT?: CloudFileChunkWhereInput | CloudFileChunkWhereInput[]
    id?: IntFilter<"CloudFileChunk"> | number
    fileId?: IntFilter<"CloudFileChunk"> | number
    seq?: IntFilter<"CloudFileChunk"> | number
    data?: BytesFilter<"CloudFileChunk"> | Bytes
    createdAt?: DateTimeFilter<"CloudFileChunk"> | Date | string
    file?: XOR<CloudFileScalarRelationFilter, CloudFileWhereInput>
  }

  export type CloudFileChunkOrderByWithRelationInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
    data?: SortOrder
    createdAt?: SortOrder
    file?: CloudFileOrderByWithRelationInput
  }

  export type CloudFileChunkWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    fileId_seq?: CloudFileChunkFileIdSeqCompoundUniqueInput
    AND?: CloudFileChunkWhereInput | CloudFileChunkWhereInput[]
    OR?: CloudFileChunkWhereInput[]
    NOT?: CloudFileChunkWhereInput | CloudFileChunkWhereInput[]
    fileId?: IntFilter<"CloudFileChunk"> | number
    seq?: IntFilter<"CloudFileChunk"> | number
    data?: BytesFilter<"CloudFileChunk"> | Bytes
    createdAt?: DateTimeFilter<"CloudFileChunk"> | Date | string
    file?: XOR<CloudFileScalarRelationFilter, CloudFileWhereInput>
  }, "id" | "fileId_seq">

  export type CloudFileChunkOrderByWithAggregationInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
    data?: SortOrder
    createdAt?: SortOrder
    _count?: CloudFileChunkCountOrderByAggregateInput
    _avg?: CloudFileChunkAvgOrderByAggregateInput
    _max?: CloudFileChunkMaxOrderByAggregateInput
    _min?: CloudFileChunkMinOrderByAggregateInput
    _sum?: CloudFileChunkSumOrderByAggregateInput
  }

  export type CloudFileChunkScalarWhereWithAggregatesInput = {
    AND?: CloudFileChunkScalarWhereWithAggregatesInput | CloudFileChunkScalarWhereWithAggregatesInput[]
    OR?: CloudFileChunkScalarWhereWithAggregatesInput[]
    NOT?: CloudFileChunkScalarWhereWithAggregatesInput | CloudFileChunkScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CloudFileChunk"> | number
    fileId?: IntWithAggregatesFilter<"CloudFileChunk"> | number
    seq?: IntWithAggregatesFilter<"CloudFileChunk"> | number
    data?: BytesWithAggregatesFilter<"CloudFileChunk"> | Bytes
    createdAt?: DateTimeWithAggregatesFilter<"CloudFileChunk"> | Date | string
  }

  export type CommunicationWhereInput = {
    AND?: CommunicationWhereInput | CommunicationWhereInput[]
    OR?: CommunicationWhereInput[]
    NOT?: CommunicationWhereInput | CommunicationWhereInput[]
    id?: IntFilter<"Communication"> | number
    patientId?: IntFilter<"Communication"> | number
    userId?: IntNullableFilter<"Communication"> | number | null
    channel?: EnumCommunicationChannelFilter<"Communication"> | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFilter<"Communication"> | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFilter<"Communication"> | $Enums.CommunicationStatus
    body?: StringNullableFilter<"Communication"> | string | null
    callDuration?: IntNullableFilter<"Communication"> | number | null
    twilioSid?: StringNullableFilter<"Communication"> | string | null
    createdAt?: DateTimeFilter<"Communication"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }

  export type CommunicationOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrderInput | SortOrder
    channel?: SortOrder
    direction?: SortOrder
    status?: SortOrder
    body?: SortOrderInput | SortOrder
    callDuration?: SortOrderInput | SortOrder
    twilioSid?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    patient?: PatientOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type CommunicationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CommunicationWhereInput | CommunicationWhereInput[]
    OR?: CommunicationWhereInput[]
    NOT?: CommunicationWhereInput | CommunicationWhereInput[]
    patientId?: IntFilter<"Communication"> | number
    userId?: IntNullableFilter<"Communication"> | number | null
    channel?: EnumCommunicationChannelFilter<"Communication"> | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFilter<"Communication"> | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFilter<"Communication"> | $Enums.CommunicationStatus
    body?: StringNullableFilter<"Communication"> | string | null
    callDuration?: IntNullableFilter<"Communication"> | number | null
    twilioSid?: StringNullableFilter<"Communication"> | string | null
    createdAt?: DateTimeFilter<"Communication"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }, "id">

  export type CommunicationOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrderInput | SortOrder
    channel?: SortOrder
    direction?: SortOrder
    status?: SortOrder
    body?: SortOrderInput | SortOrder
    callDuration?: SortOrderInput | SortOrder
    twilioSid?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: CommunicationCountOrderByAggregateInput
    _avg?: CommunicationAvgOrderByAggregateInput
    _max?: CommunicationMaxOrderByAggregateInput
    _min?: CommunicationMinOrderByAggregateInput
    _sum?: CommunicationSumOrderByAggregateInput
  }

  export type CommunicationScalarWhereWithAggregatesInput = {
    AND?: CommunicationScalarWhereWithAggregatesInput | CommunicationScalarWhereWithAggregatesInput[]
    OR?: CommunicationScalarWhereWithAggregatesInput[]
    NOT?: CommunicationScalarWhereWithAggregatesInput | CommunicationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Communication"> | number
    patientId?: IntWithAggregatesFilter<"Communication"> | number
    userId?: IntNullableWithAggregatesFilter<"Communication"> | number | null
    channel?: EnumCommunicationChannelWithAggregatesFilter<"Communication"> | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionWithAggregatesFilter<"Communication"> | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusWithAggregatesFilter<"Communication"> | $Enums.CommunicationStatus
    body?: StringNullableWithAggregatesFilter<"Communication"> | string | null
    callDuration?: IntNullableWithAggregatesFilter<"Communication"> | number | null
    twilioSid?: StringNullableWithAggregatesFilter<"Communication"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Communication"> | Date | string
  }

  export type PatientDocumentWhereInput = {
    AND?: PatientDocumentWhereInput | PatientDocumentWhereInput[]
    OR?: PatientDocumentWhereInput[]
    NOT?: PatientDocumentWhereInput | PatientDocumentWhereInput[]
    id?: IntFilter<"PatientDocument"> | number
    patientId?: IntFilter<"PatientDocument"> | number
    filename?: StringFilter<"PatientDocument"> | string
    originalName?: StringFilter<"PatientDocument"> | string
    mimeType?: StringFilter<"PatientDocument"> | string
    fileSize?: BigIntFilter<"PatientDocument"> | bigint | number
    filePath?: StringFilter<"PatientDocument"> | string
    uploadedAt?: DateTimeFilter<"PatientDocument"> | Date | string
    updatedAt?: DateTimeFilter<"PatientDocument"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
  }

  export type PatientDocumentOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    filename?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    filePath?: SortOrder
    uploadedAt?: SortOrder
    updatedAt?: SortOrder
    patient?: PatientOrderByWithRelationInput
  }

  export type PatientDocumentWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PatientDocumentWhereInput | PatientDocumentWhereInput[]
    OR?: PatientDocumentWhereInput[]
    NOT?: PatientDocumentWhereInput | PatientDocumentWhereInput[]
    patientId?: IntFilter<"PatientDocument"> | number
    filename?: StringFilter<"PatientDocument"> | string
    originalName?: StringFilter<"PatientDocument"> | string
    mimeType?: StringFilter<"PatientDocument"> | string
    fileSize?: BigIntFilter<"PatientDocument"> | bigint | number
    filePath?: StringFilter<"PatientDocument"> | string
    uploadedAt?: DateTimeFilter<"PatientDocument"> | Date | string
    updatedAt?: DateTimeFilter<"PatientDocument"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
  }, "id">

  export type PatientDocumentOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    filename?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    filePath?: SortOrder
    uploadedAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PatientDocumentCountOrderByAggregateInput
    _avg?: PatientDocumentAvgOrderByAggregateInput
    _max?: PatientDocumentMaxOrderByAggregateInput
    _min?: PatientDocumentMinOrderByAggregateInput
    _sum?: PatientDocumentSumOrderByAggregateInput
  }

  export type PatientDocumentScalarWhereWithAggregatesInput = {
    AND?: PatientDocumentScalarWhereWithAggregatesInput | PatientDocumentScalarWhereWithAggregatesInput[]
    OR?: PatientDocumentScalarWhereWithAggregatesInput[]
    NOT?: PatientDocumentScalarWhereWithAggregatesInput | PatientDocumentScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PatientDocument"> | number
    patientId?: IntWithAggregatesFilter<"PatientDocument"> | number
    filename?: StringWithAggregatesFilter<"PatientDocument"> | string
    originalName?: StringWithAggregatesFilter<"PatientDocument"> | string
    mimeType?: StringWithAggregatesFilter<"PatientDocument"> | string
    fileSize?: BigIntWithAggregatesFilter<"PatientDocument"> | bigint | number
    filePath?: StringWithAggregatesFilter<"PatientDocument"> | string
    uploadedAt?: DateTimeWithAggregatesFilter<"PatientDocument"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"PatientDocument"> | Date | string
  }

  export type TwilioSettingsWhereInput = {
    AND?: TwilioSettingsWhereInput | TwilioSettingsWhereInput[]
    OR?: TwilioSettingsWhereInput[]
    NOT?: TwilioSettingsWhereInput | TwilioSettingsWhereInput[]
    id?: IntFilter<"TwilioSettings"> | number
    userId?: IntFilter<"TwilioSettings"> | number
    accountSid?: StringFilter<"TwilioSettings"> | string
    authToken?: StringFilter<"TwilioSettings"> | string
    phoneNumber?: StringFilter<"TwilioSettings"> | string
    greetingMessage?: StringNullableFilter<"TwilioSettings"> | string | null
    templates?: JsonNullableFilter<"TwilioSettings">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type TwilioSettingsOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    accountSid?: SortOrder
    authToken?: SortOrder
    phoneNumber?: SortOrder
    greetingMessage?: SortOrderInput | SortOrder
    templates?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type TwilioSettingsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId?: number
    AND?: TwilioSettingsWhereInput | TwilioSettingsWhereInput[]
    OR?: TwilioSettingsWhereInput[]
    NOT?: TwilioSettingsWhereInput | TwilioSettingsWhereInput[]
    accountSid?: StringFilter<"TwilioSettings"> | string
    authToken?: StringFilter<"TwilioSettings"> | string
    phoneNumber?: StringFilter<"TwilioSettings"> | string
    greetingMessage?: StringNullableFilter<"TwilioSettings"> | string | null
    templates?: JsonNullableFilter<"TwilioSettings">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type TwilioSettingsOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    accountSid?: SortOrder
    authToken?: SortOrder
    phoneNumber?: SortOrder
    greetingMessage?: SortOrderInput | SortOrder
    templates?: SortOrderInput | SortOrder
    _count?: TwilioSettingsCountOrderByAggregateInput
    _avg?: TwilioSettingsAvgOrderByAggregateInput
    _max?: TwilioSettingsMaxOrderByAggregateInput
    _min?: TwilioSettingsMinOrderByAggregateInput
    _sum?: TwilioSettingsSumOrderByAggregateInput
  }

  export type TwilioSettingsScalarWhereWithAggregatesInput = {
    AND?: TwilioSettingsScalarWhereWithAggregatesInput | TwilioSettingsScalarWhereWithAggregatesInput[]
    OR?: TwilioSettingsScalarWhereWithAggregatesInput[]
    NOT?: TwilioSettingsScalarWhereWithAggregatesInput | TwilioSettingsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"TwilioSettings"> | number
    userId?: IntWithAggregatesFilter<"TwilioSettings"> | number
    accountSid?: StringWithAggregatesFilter<"TwilioSettings"> | string
    authToken?: StringWithAggregatesFilter<"TwilioSettings"> | string
    phoneNumber?: StringWithAggregatesFilter<"TwilioSettings"> | string
    greetingMessage?: StringNullableWithAggregatesFilter<"TwilioSettings"> | string | null
    templates?: JsonNullableWithAggregatesFilter<"TwilioSettings">
  }

  export type AiSettingsWhereInput = {
    AND?: AiSettingsWhereInput | AiSettingsWhereInput[]
    OR?: AiSettingsWhereInput[]
    NOT?: AiSettingsWhereInput | AiSettingsWhereInput[]
    id?: IntFilter<"AiSettings"> | number
    userId?: IntFilter<"AiSettings"> | number
    apiKey?: StringFilter<"AiSettings"> | string
    afterHoursEnabled?: BoolFilter<"AiSettings"> | boolean
    openPhoneReply?: BoolFilter<"AiSettings"> | boolean
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AiSettingsOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    apiKey?: SortOrder
    afterHoursEnabled?: SortOrder
    openPhoneReply?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type AiSettingsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId?: number
    AND?: AiSettingsWhereInput | AiSettingsWhereInput[]
    OR?: AiSettingsWhereInput[]
    NOT?: AiSettingsWhereInput | AiSettingsWhereInput[]
    apiKey?: StringFilter<"AiSettings"> | string
    afterHoursEnabled?: BoolFilter<"AiSettings"> | boolean
    openPhoneReply?: BoolFilter<"AiSettings"> | boolean
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type AiSettingsOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    apiKey?: SortOrder
    afterHoursEnabled?: SortOrder
    openPhoneReply?: SortOrder
    _count?: AiSettingsCountOrderByAggregateInput
    _avg?: AiSettingsAvgOrderByAggregateInput
    _max?: AiSettingsMaxOrderByAggregateInput
    _min?: AiSettingsMinOrderByAggregateInput
    _sum?: AiSettingsSumOrderByAggregateInput
  }

  export type AiSettingsScalarWhereWithAggregatesInput = {
    AND?: AiSettingsScalarWhereWithAggregatesInput | AiSettingsScalarWhereWithAggregatesInput[]
    OR?: AiSettingsScalarWhereWithAggregatesInput[]
    NOT?: AiSettingsScalarWhereWithAggregatesInput | AiSettingsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"AiSettings"> | number
    userId?: IntWithAggregatesFilter<"AiSettings"> | number
    apiKey?: StringWithAggregatesFilter<"AiSettings"> | string
    afterHoursEnabled?: BoolWithAggregatesFilter<"AiSettings"> | boolean
    openPhoneReply?: BoolWithAggregatesFilter<"AiSettings"> | boolean
  }

  export type OfficeHoursWhereInput = {
    AND?: OfficeHoursWhereInput | OfficeHoursWhereInput[]
    OR?: OfficeHoursWhereInput[]
    NOT?: OfficeHoursWhereInput | OfficeHoursWhereInput[]
    id?: IntFilter<"OfficeHours"> | number
    userId?: IntFilter<"OfficeHours"> | number
    data?: JsonFilter<"OfficeHours">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type OfficeHoursOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type OfficeHoursWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId?: number
    AND?: OfficeHoursWhereInput | OfficeHoursWhereInput[]
    OR?: OfficeHoursWhereInput[]
    NOT?: OfficeHoursWhereInput | OfficeHoursWhereInput[]
    data?: JsonFilter<"OfficeHours">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type OfficeHoursOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
    _count?: OfficeHoursCountOrderByAggregateInput
    _avg?: OfficeHoursAvgOrderByAggregateInput
    _max?: OfficeHoursMaxOrderByAggregateInput
    _min?: OfficeHoursMinOrderByAggregateInput
    _sum?: OfficeHoursSumOrderByAggregateInput
  }

  export type OfficeHoursScalarWhereWithAggregatesInput = {
    AND?: OfficeHoursScalarWhereWithAggregatesInput | OfficeHoursScalarWhereWithAggregatesInput[]
    OR?: OfficeHoursScalarWhereWithAggregatesInput[]
    NOT?: OfficeHoursScalarWhereWithAggregatesInput | OfficeHoursScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"OfficeHours"> | number
    userId?: IntWithAggregatesFilter<"OfficeHours"> | number
    data?: JsonWithAggregatesFilter<"OfficeHours">
  }

  export type OfficeContactWhereInput = {
    AND?: OfficeContactWhereInput | OfficeContactWhereInput[]
    OR?: OfficeContactWhereInput[]
    NOT?: OfficeContactWhereInput | OfficeContactWhereInput[]
    id?: IntFilter<"OfficeContact"> | number
    userId?: IntFilter<"OfficeContact"> | number
    officeName?: StringNullableFilter<"OfficeContact"> | string | null
    receptionistName?: StringNullableFilter<"OfficeContact"> | string | null
    dentistName?: StringNullableFilter<"OfficeContact"> | string | null
    phoneNumber?: StringNullableFilter<"OfficeContact"> | string | null
    email?: StringNullableFilter<"OfficeContact"> | string | null
    fax?: StringNullableFilter<"OfficeContact"> | string | null
    streetAddress?: StringNullableFilter<"OfficeContact"> | string | null
    city?: StringNullableFilter<"OfficeContact"> | string | null
    state?: StringNullableFilter<"OfficeContact"> | string | null
    zipCode?: StringNullableFilter<"OfficeContact"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type OfficeContactOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    officeName?: SortOrderInput | SortOrder
    receptionistName?: SortOrderInput | SortOrder
    dentistName?: SortOrderInput | SortOrder
    phoneNumber?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    fax?: SortOrderInput | SortOrder
    streetAddress?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    zipCode?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type OfficeContactWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId?: number
    AND?: OfficeContactWhereInput | OfficeContactWhereInput[]
    OR?: OfficeContactWhereInput[]
    NOT?: OfficeContactWhereInput | OfficeContactWhereInput[]
    officeName?: StringNullableFilter<"OfficeContact"> | string | null
    receptionistName?: StringNullableFilter<"OfficeContact"> | string | null
    dentistName?: StringNullableFilter<"OfficeContact"> | string | null
    phoneNumber?: StringNullableFilter<"OfficeContact"> | string | null
    email?: StringNullableFilter<"OfficeContact"> | string | null
    fax?: StringNullableFilter<"OfficeContact"> | string | null
    streetAddress?: StringNullableFilter<"OfficeContact"> | string | null
    city?: StringNullableFilter<"OfficeContact"> | string | null
    state?: StringNullableFilter<"OfficeContact"> | string | null
    zipCode?: StringNullableFilter<"OfficeContact"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type OfficeContactOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    officeName?: SortOrderInput | SortOrder
    receptionistName?: SortOrderInput | SortOrder
    dentistName?: SortOrderInput | SortOrder
    phoneNumber?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    fax?: SortOrderInput | SortOrder
    streetAddress?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    zipCode?: SortOrderInput | SortOrder
    _count?: OfficeContactCountOrderByAggregateInput
    _avg?: OfficeContactAvgOrderByAggregateInput
    _max?: OfficeContactMaxOrderByAggregateInput
    _min?: OfficeContactMinOrderByAggregateInput
    _sum?: OfficeContactSumOrderByAggregateInput
  }

  export type OfficeContactScalarWhereWithAggregatesInput = {
    AND?: OfficeContactScalarWhereWithAggregatesInput | OfficeContactScalarWhereWithAggregatesInput[]
    OR?: OfficeContactScalarWhereWithAggregatesInput[]
    NOT?: OfficeContactScalarWhereWithAggregatesInput | OfficeContactScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"OfficeContact"> | number
    userId?: IntWithAggregatesFilter<"OfficeContact"> | number
    officeName?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    receptionistName?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    dentistName?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    phoneNumber?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    email?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    fax?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    streetAddress?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    city?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    state?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
    zipCode?: StringNullableWithAggregatesFilter<"OfficeContact"> | string | null
  }

  export type InsuranceContactWhereInput = {
    AND?: InsuranceContactWhereInput | InsuranceContactWhereInput[]
    OR?: InsuranceContactWhereInput[]
    NOT?: InsuranceContactWhereInput | InsuranceContactWhereInput[]
    id?: IntFilter<"InsuranceContact"> | number
    userId?: IntFilter<"InsuranceContact"> | number
    name?: StringFilter<"InsuranceContact"> | string
    phoneNumber?: StringNullableFilter<"InsuranceContact"> | string | null
    createdAt?: DateTimeFilter<"InsuranceContact"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type InsuranceContactOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    phoneNumber?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type InsuranceContactWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: InsuranceContactWhereInput | InsuranceContactWhereInput[]
    OR?: InsuranceContactWhereInput[]
    NOT?: InsuranceContactWhereInput | InsuranceContactWhereInput[]
    userId?: IntFilter<"InsuranceContact"> | number
    name?: StringFilter<"InsuranceContact"> | string
    phoneNumber?: StringNullableFilter<"InsuranceContact"> | string | null
    createdAt?: DateTimeFilter<"InsuranceContact"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type InsuranceContactOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    phoneNumber?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: InsuranceContactCountOrderByAggregateInput
    _avg?: InsuranceContactAvgOrderByAggregateInput
    _max?: InsuranceContactMaxOrderByAggregateInput
    _min?: InsuranceContactMinOrderByAggregateInput
    _sum?: InsuranceContactSumOrderByAggregateInput
  }

  export type InsuranceContactScalarWhereWithAggregatesInput = {
    AND?: InsuranceContactScalarWhereWithAggregatesInput | InsuranceContactScalarWhereWithAggregatesInput[]
    OR?: InsuranceContactScalarWhereWithAggregatesInput[]
    NOT?: InsuranceContactScalarWhereWithAggregatesInput | InsuranceContactScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"InsuranceContact"> | number
    userId?: IntWithAggregatesFilter<"InsuranceContact"> | number
    name?: StringWithAggregatesFilter<"InsuranceContact"> | string
    phoneNumber?: StringNullableWithAggregatesFilter<"InsuranceContact"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"InsuranceContact"> | Date | string
  }

  export type ProcedureTimeslotWhereInput = {
    AND?: ProcedureTimeslotWhereInput | ProcedureTimeslotWhereInput[]
    OR?: ProcedureTimeslotWhereInput[]
    NOT?: ProcedureTimeslotWhereInput | ProcedureTimeslotWhereInput[]
    id?: IntFilter<"ProcedureTimeslot"> | number
    userId?: IntFilter<"ProcedureTimeslot"> | number
    data?: JsonFilter<"ProcedureTimeslot">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type ProcedureTimeslotOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type ProcedureTimeslotWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    userId?: number
    AND?: ProcedureTimeslotWhereInput | ProcedureTimeslotWhereInput[]
    OR?: ProcedureTimeslotWhereInput[]
    NOT?: ProcedureTimeslotWhereInput | ProcedureTimeslotWhereInput[]
    data?: JsonFilter<"ProcedureTimeslot">
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type ProcedureTimeslotOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
    _count?: ProcedureTimeslotCountOrderByAggregateInput
    _avg?: ProcedureTimeslotAvgOrderByAggregateInput
    _max?: ProcedureTimeslotMaxOrderByAggregateInput
    _min?: ProcedureTimeslotMinOrderByAggregateInput
    _sum?: ProcedureTimeslotSumOrderByAggregateInput
  }

  export type ProcedureTimeslotScalarWhereWithAggregatesInput = {
    AND?: ProcedureTimeslotScalarWhereWithAggregatesInput | ProcedureTimeslotScalarWhereWithAggregatesInput[]
    OR?: ProcedureTimeslotScalarWhereWithAggregatesInput[]
    NOT?: ProcedureTimeslotScalarWhereWithAggregatesInput | ProcedureTimeslotScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ProcedureTimeslot"> | number
    userId?: IntWithAggregatesFilter<"ProcedureTimeslot"> | number
    data?: JsonWithAggregatesFilter<"ProcedureTimeslot">
  }

  export type PatientConversationWhereInput = {
    AND?: PatientConversationWhereInput | PatientConversationWhereInput[]
    OR?: PatientConversationWhereInput[]
    NOT?: PatientConversationWhereInput | PatientConversationWhereInput[]
    id?: IntFilter<"PatientConversation"> | number
    patientId?: IntFilter<"PatientConversation"> | number
    userId?: IntFilter<"PatientConversation"> | number
    stage?: StringFilter<"PatientConversation"> | string
    aiHandoff?: BoolFilter<"PatientConversation"> | boolean
    updatedAt?: DateTimeFilter<"PatientConversation"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type PatientConversationOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    stage?: SortOrder
    aiHandoff?: SortOrder
    updatedAt?: SortOrder
    patient?: PatientOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type PatientConversationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    patientId?: number
    AND?: PatientConversationWhereInput | PatientConversationWhereInput[]
    OR?: PatientConversationWhereInput[]
    NOT?: PatientConversationWhereInput | PatientConversationWhereInput[]
    userId?: IntFilter<"PatientConversation"> | number
    stage?: StringFilter<"PatientConversation"> | string
    aiHandoff?: BoolFilter<"PatientConversation"> | boolean
    updatedAt?: DateTimeFilter<"PatientConversation"> | Date | string
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "patientId">

  export type PatientConversationOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    stage?: SortOrder
    aiHandoff?: SortOrder
    updatedAt?: SortOrder
    _count?: PatientConversationCountOrderByAggregateInput
    _avg?: PatientConversationAvgOrderByAggregateInput
    _max?: PatientConversationMaxOrderByAggregateInput
    _min?: PatientConversationMinOrderByAggregateInput
    _sum?: PatientConversationSumOrderByAggregateInput
  }

  export type PatientConversationScalarWhereWithAggregatesInput = {
    AND?: PatientConversationScalarWhereWithAggregatesInput | PatientConversationScalarWhereWithAggregatesInput[]
    OR?: PatientConversationScalarWhereWithAggregatesInput[]
    NOT?: PatientConversationScalarWhereWithAggregatesInput | PatientConversationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PatientConversation"> | number
    patientId?: IntWithAggregatesFilter<"PatientConversation"> | number
    userId?: IntWithAggregatesFilter<"PatientConversation"> | number
    stage?: StringWithAggregatesFilter<"PatientConversation"> | string
    aiHandoff?: BoolWithAggregatesFilter<"PatientConversation"> | boolean
    updatedAt?: DateTimeWithAggregatesFilter<"PatientConversation"> | Date | string
  }

  export type CommissionBatchWhereInput = {
    AND?: CommissionBatchWhereInput | CommissionBatchWhereInput[]
    OR?: CommissionBatchWhereInput[]
    NOT?: CommissionBatchWhereInput | CommissionBatchWhereInput[]
    id?: IntFilter<"CommissionBatch"> | number
    npiProviderId?: IntFilter<"CommissionBatch"> | number
    totalCollection?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    notes?: StringNullableFilter<"CommissionBatch"> | string | null
    createdAt?: DateTimeFilter<"CommissionBatch"> | Date | string
    npiProvider?: XOR<NpiProviderScalarRelationFilter, NpiProviderWhereInput>
    items?: CommissionBatchItemListRelationFilter
  }

  export type CommissionBatchOrderByWithRelationInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
    notes?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    npiProvider?: NpiProviderOrderByWithRelationInput
    items?: CommissionBatchItemOrderByRelationAggregateInput
  }

  export type CommissionBatchWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CommissionBatchWhereInput | CommissionBatchWhereInput[]
    OR?: CommissionBatchWhereInput[]
    NOT?: CommissionBatchWhereInput | CommissionBatchWhereInput[]
    npiProviderId?: IntFilter<"CommissionBatch"> | number
    totalCollection?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    notes?: StringNullableFilter<"CommissionBatch"> | string | null
    createdAt?: DateTimeFilter<"CommissionBatch"> | Date | string
    npiProvider?: XOR<NpiProviderScalarRelationFilter, NpiProviderWhereInput>
    items?: CommissionBatchItemListRelationFilter
  }, "id">

  export type CommissionBatchOrderByWithAggregationInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
    notes?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: CommissionBatchCountOrderByAggregateInput
    _avg?: CommissionBatchAvgOrderByAggregateInput
    _max?: CommissionBatchMaxOrderByAggregateInput
    _min?: CommissionBatchMinOrderByAggregateInput
    _sum?: CommissionBatchSumOrderByAggregateInput
  }

  export type CommissionBatchScalarWhereWithAggregatesInput = {
    AND?: CommissionBatchScalarWhereWithAggregatesInput | CommissionBatchScalarWhereWithAggregatesInput[]
    OR?: CommissionBatchScalarWhereWithAggregatesInput[]
    NOT?: CommissionBatchScalarWhereWithAggregatesInput | CommissionBatchScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CommissionBatch"> | number
    npiProviderId?: IntWithAggregatesFilter<"CommissionBatch"> | number
    totalCollection?: DecimalWithAggregatesFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalWithAggregatesFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    notes?: StringNullableWithAggregatesFilter<"CommissionBatch"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"CommissionBatch"> | Date | string
  }

  export type CommissionBatchItemWhereInput = {
    AND?: CommissionBatchItemWhereInput | CommissionBatchItemWhereInput[]
    OR?: CommissionBatchItemWhereInput[]
    NOT?: CommissionBatchItemWhereInput | CommissionBatchItemWhereInput[]
    id?: IntFilter<"CommissionBatchItem"> | number
    commissionBatchId?: IntFilter<"CommissionBatchItem"> | number
    paymentId?: IntFilter<"CommissionBatchItem"> | number
    collectionAmount?: DecimalFilter<"CommissionBatchItem"> | Decimal | DecimalJsLike | number | string
    commissionBatch?: XOR<CommissionBatchScalarRelationFilter, CommissionBatchWhereInput>
    payment?: XOR<PaymentScalarRelationFilter, PaymentWhereInput>
  }

  export type CommissionBatchItemOrderByWithRelationInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
    commissionBatch?: CommissionBatchOrderByWithRelationInput
    payment?: PaymentOrderByWithRelationInput
  }

  export type CommissionBatchItemWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    commissionBatchId_paymentId?: CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput
    AND?: CommissionBatchItemWhereInput | CommissionBatchItemWhereInput[]
    OR?: CommissionBatchItemWhereInput[]
    NOT?: CommissionBatchItemWhereInput | CommissionBatchItemWhereInput[]
    commissionBatchId?: IntFilter<"CommissionBatchItem"> | number
    paymentId?: IntFilter<"CommissionBatchItem"> | number
    collectionAmount?: DecimalFilter<"CommissionBatchItem"> | Decimal | DecimalJsLike | number | string
    commissionBatch?: XOR<CommissionBatchScalarRelationFilter, CommissionBatchWhereInput>
    payment?: XOR<PaymentScalarRelationFilter, PaymentWhereInput>
  }, "id" | "commissionBatchId_paymentId">

  export type CommissionBatchItemOrderByWithAggregationInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
    _count?: CommissionBatchItemCountOrderByAggregateInput
    _avg?: CommissionBatchItemAvgOrderByAggregateInput
    _max?: CommissionBatchItemMaxOrderByAggregateInput
    _min?: CommissionBatchItemMinOrderByAggregateInput
    _sum?: CommissionBatchItemSumOrderByAggregateInput
  }

  export type CommissionBatchItemScalarWhereWithAggregatesInput = {
    AND?: CommissionBatchItemScalarWhereWithAggregatesInput | CommissionBatchItemScalarWhereWithAggregatesInput[]
    OR?: CommissionBatchItemScalarWhereWithAggregatesInput[]
    NOT?: CommissionBatchItemScalarWhereWithAggregatesInput | CommissionBatchItemScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CommissionBatchItem"> | number
    commissionBatchId?: IntWithAggregatesFilter<"CommissionBatchItem"> | number
    paymentId?: IntWithAggregatesFilter<"CommissionBatchItem"> | number
    collectionAmount?: DecimalWithAggregatesFilter<"CommissionBatchItem"> | Decimal | DecimalJsLike | number | string
  }

  export type UserCreateInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
  }

  export type UserUpdateManyMutationInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
  }

  export type UserUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PatientCreateInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientUpdateInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type PatientCreateManyInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PatientUpdateManyMutationInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentCreateManyInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type AppointmentUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  export type AppointmentUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  export type AppointmentFileCreateInput = {
    filename: string
    mimeType?: string | null
    filePath?: string | null
    appointment: AppointmentCreateNestedOneWithoutFilesInput
  }

  export type AppointmentFileUncheckedCreateInput = {
    id?: number
    appointmentId: number
    filename: string
    mimeType?: string | null
    filePath?: string | null
  }

  export type AppointmentFileUpdateInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    appointment?: AppointmentUpdateOneRequiredWithoutFilesNestedInput
  }

  export type AppointmentFileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentFileCreateManyInput = {
    id?: number
    appointmentId: number
    filename: string
    mimeType?: string | null
    filePath?: string | null
  }

  export type AppointmentFileUpdateManyMutationInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentFileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type StaffCreateInput = {
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    user?: UserCreateNestedOneWithoutStaffInput
    appointments?: AppointmentCreateNestedManyWithoutStaffInput
    claims?: ClaimCreateNestedManyWithoutStaffInput
  }

  export type StaffUncheckedCreateInput = {
    id?: number
    userId: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutStaffInput
    claims?: ClaimUncheckedCreateNestedManyWithoutStaffInput
  }

  export type StaffUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutStaffNestedInput
    appointments?: AppointmentUpdateManyWithoutStaffNestedInput
    claims?: ClaimUpdateManyWithoutStaffNestedInput
  }

  export type StaffUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutStaffNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutStaffNestedInput
  }

  export type StaffCreateManyInput = {
    id?: number
    userId: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
  }

  export type StaffUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StaffUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NpiProviderCreateInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutNpiProvidersInput
    claims?: ClaimCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentUncheckedCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUpdateInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
    claims?: ClaimUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderCreateManyInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
  }

  export type NpiProviderUpdateManyMutationInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NpiProviderUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureCreateInput = {
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
    appointment: AppointmentCreateNestedOneWithoutProceduresInput
    patient: PatientCreateNestedOneWithoutProceduresInput
    npiProvider?: NpiProviderCreateNestedOneWithoutAppointmentProceduresInput
  }

  export type AppointmentProcedureUncheckedCreateInput = {
    id?: number
    appointmentId: number
    patientId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureUpdateInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointment?: AppointmentUpdateOneRequiredWithoutProceduresNestedInput
    patient?: PatientUpdateOneRequiredWithoutProceduresNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutAppointmentProceduresNestedInput
  }

  export type AppointmentProcedureUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureCreateManyInput = {
    id?: number
    appointmentId: number
    patientId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureUpdateManyMutationInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ClaimCreateInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimUpdateInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimCreateManyInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
  }

  export type ClaimUpdateManyMutationInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClaimUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ServiceLineCreateInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    claim?: ClaimCreateNestedOneWithoutServiceLinesInput
    payment?: PaymentCreateNestedOneWithoutServiceLinesInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineUncheckedCreateInput = {
    id?: number
    claimId?: number | null
    paymentId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineUpdateInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    claim?: ClaimUpdateOneWithoutServiceLinesNestedInput
    payment?: PaymentUpdateOneWithoutServiceLinesNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    paymentId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineCreateManyInput = {
    id?: number
    claimId?: number | null
    paymentId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
  }

  export type ServiceLineUpdateManyMutationInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
  }

  export type ServiceLineUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    paymentId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
  }

  export type ClaimFileCreateInput = {
    filename: string
    mimeType: string
    filePath?: string | null
    claim: ClaimCreateNestedOneWithoutClaimFilesInput
  }

  export type ClaimFileUncheckedCreateInput = {
    id?: number
    claimId: number
    filename: string
    mimeType: string
    filePath?: string | null
  }

  export type ClaimFileUpdateInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    claim?: ClaimUpdateOneRequiredWithoutClaimFilesNestedInput
  }

  export type ClaimFileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClaimFileCreateManyInput = {
    id?: number
    claimId: number
    filename: string
    mimeType: string
    filePath?: string | null
  }

  export type ClaimFileUpdateManyMutationInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClaimFileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type InsuranceCredentialCreateInput = {
    siteKey: string
    username: string
    password: string
    user: UserCreateNestedOneWithoutInsuranceCredentialsInput
  }

  export type InsuranceCredentialUncheckedCreateInput = {
    id?: number
    userId: number
    siteKey: string
    username: string
    password: string
  }

  export type InsuranceCredentialUpdateInput = {
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutInsuranceCredentialsNestedInput
  }

  export type InsuranceCredentialUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type InsuranceCredentialCreateManyInput = {
    id?: number
    userId: number
    siteKey: string
    username: string
    password: string
  }

  export type InsuranceCredentialUpdateManyMutationInput = {
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type InsuranceCredentialUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorCreateInput = {
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
    user: UserCreateNestedOneWithoutShoppingVendorsInput
  }

  export type ShoppingVendorUncheckedCreateInput = {
    id?: number
    userId: number
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
  }

  export type ShoppingVendorUpdateInput = {
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutShoppingVendorsNestedInput
  }

  export type ShoppingVendorUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorCreateManyInput = {
    id?: number
    userId: number
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
  }

  export type ShoppingVendorUpdateManyMutationInput = {
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type PdfGroupCreateInput = {
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    patient: PatientCreateNestedOneWithoutGroupsInput
    pdfs?: PdfFileCreateNestedManyWithoutGroupInput
  }

  export type PdfGroupUncheckedCreateInput = {
    id?: number
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    patientId: number
    pdfs?: PdfFileUncheckedCreateNestedManyWithoutGroupInput
  }

  export type PdfGroupUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutGroupsNestedInput
    pdfs?: PdfFileUpdateManyWithoutGroupNestedInput
  }

  export type PdfGroupUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patientId?: IntFieldUpdateOperationsInput | number
    pdfs?: PdfFileUncheckedUpdateManyWithoutGroupNestedInput
  }

  export type PdfGroupCreateManyInput = {
    id?: number
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    patientId: number
  }

  export type PdfGroupUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PdfGroupUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patientId?: IntFieldUpdateOperationsInput | number
  }

  export type PdfFileCreateInput = {
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
    group: PdfGroupCreateNestedOneWithoutPdfsInput
  }

  export type PdfFileUncheckedCreateInput = {
    id?: number
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
    groupId: number
  }

  export type PdfFileUpdateInput = {
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    group?: PdfGroupUpdateOneRequiredWithoutPdfsNestedInput
  }

  export type PdfFileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    groupId?: IntFieldUpdateOperationsInput | number
  }

  export type PdfFileCreateManyInput = {
    id?: number
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
    groupId: number
  }

  export type PdfFileUpdateManyMutationInput = {
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PdfFileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    groupId?: IntFieldUpdateOperationsInput | number
  }

  export type PaymentCreateInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUpdateInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentCreateManyInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentUpdateManyMutationInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionCreateInput = {
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
    payment: PaymentCreateNestedOneWithoutServiceLineTransactionsInput
    serviceLine: ServiceLineCreateNestedOneWithoutServiceLineTransactionsInput
  }

  export type ServiceLineTransactionUncheckedCreateInput = {
    id?: number
    paymentId: number
    serviceLineId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineTransactionUpdateInput = {
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payment?: PaymentUpdateOneRequiredWithoutServiceLineTransactionsNestedInput
    serviceLine?: ServiceLineUpdateOneRequiredWithoutServiceLineTransactionsNestedInput
  }

  export type ServiceLineTransactionUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    serviceLineId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionCreateManyInput = {
    id?: number
    paymentId: number
    serviceLineId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineTransactionUpdateManyMutationInput = {
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    serviceLineId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupCreateInput = {
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutBackupsInput
  }

  export type DatabaseBackupUncheckedCreateInput = {
    id?: number
    userId: number
    createdAt?: Date | string
  }

  export type DatabaseBackupUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutBackupsNestedInput
  }

  export type DatabaseBackupUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupCreateManyInput = {
    id?: number
    userId: number
    createdAt?: Date | string
  }

  export type DatabaseBackupUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationCreateInput = {
    path: string
    isActive?: boolean
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutBackupDestinationsInput
  }

  export type BackupDestinationUncheckedCreateInput = {
    id?: number
    userId: number
    path: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type BackupDestinationUpdateInput = {
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutBackupDestinationsNestedInput
  }

  export type BackupDestinationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationCreateManyInput = {
    id?: number
    userId: number
    path: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type BackupDestinationUpdateManyMutationInput = {
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationCreateInput = {
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
    user: UserCreateNestedOneWithoutNotificationsInput
  }

  export type NotificationUncheckedCreateInput = {
    id?: number
    userId: number
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
  }

  export type NotificationUpdateInput = {
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
    user?: UserUpdateOneRequiredWithoutNotificationsNestedInput
  }

  export type NotificationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationCreateManyInput = {
    id?: number
    userId: number
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
  }

  export type NotificationUpdateManyMutationInput = {
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CronJobLogCreateInput = {
    jobName: string
    status: string
    startedAt: Date | string
    completedAt?: Date | string | null
    durationMs?: number | null
    errorMessage?: string | null
  }

  export type CronJobLogUncheckedCreateInput = {
    id?: number
    jobName: string
    status: string
    startedAt: Date | string
    completedAt?: Date | string | null
    durationMs?: number | null
    errorMessage?: string | null
  }

  export type CronJobLogUpdateInput = {
    jobName?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    startedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    durationMs?: NullableIntFieldUpdateOperationsInput | number | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CronJobLogUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    jobName?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    startedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    durationMs?: NullableIntFieldUpdateOperationsInput | number | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CronJobLogCreateManyInput = {
    id?: number
    jobName: string
    status: string
    startedAt: Date | string
    completedAt?: Date | string | null
    durationMs?: number | null
    errorMessage?: string | null
  }

  export type CronJobLogUpdateManyMutationInput = {
    jobName?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    startedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    durationMs?: NullableIntFieldUpdateOperationsInput | number | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CronJobLogUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    jobName?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    startedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    durationMs?: NullableIntFieldUpdateOperationsInput | number | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CloudFolderCreateInput = {
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    parent?: CloudFolderCreateNestedOneWithoutChildrenInput
    children?: CloudFolderCreateNestedManyWithoutParentInput
    user: UserCreateNestedOneWithoutCloudFoldersInput
    files?: CloudFileCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderUncheckedCreateInput = {
    id?: number
    userId: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    children?: CloudFolderUncheckedCreateNestedManyWithoutParentInput
    files?: CloudFileUncheckedCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    parent?: CloudFolderUpdateOneWithoutChildrenNestedInput
    children?: CloudFolderUpdateManyWithoutParentNestedInput
    user?: UserUpdateOneRequiredWithoutCloudFoldersNestedInput
    files?: CloudFileUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    children?: CloudFolderUncheckedUpdateManyWithoutParentNestedInput
    files?: CloudFileUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderCreateManyInput = {
    id?: number
    userId: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFolderUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFolderUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileCreateInput = {
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutCloudFilesInput
    folder?: CloudFolderCreateNestedOneWithoutFilesInput
    chunks?: CloudFileChunkCreateNestedManyWithoutFileInput
  }

  export type CloudFileUncheckedCreateInput = {
    id?: number
    userId: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    folderId?: number | null
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    chunks?: CloudFileChunkUncheckedCreateNestedManyWithoutFileInput
  }

  export type CloudFileUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutCloudFilesNestedInput
    folder?: CloudFolderUpdateOneWithoutFilesNestedInput
    chunks?: CloudFileChunkUpdateManyWithoutFileNestedInput
  }

  export type CloudFileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    folderId?: NullableIntFieldUpdateOperationsInput | number | null
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chunks?: CloudFileChunkUncheckedUpdateManyWithoutFileNestedInput
  }

  export type CloudFileCreateManyInput = {
    id?: number
    userId: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    folderId?: number | null
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFileUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    folderId?: NullableIntFieldUpdateOperationsInput | number | null
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkCreateInput = {
    seq: number
    data: Bytes
    createdAt?: Date | string
    file: CloudFileCreateNestedOneWithoutChunksInput
  }

  export type CloudFileChunkUncheckedCreateInput = {
    id?: number
    fileId: number
    seq: number
    data: Bytes
    createdAt?: Date | string
  }

  export type CloudFileChunkUpdateInput = {
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    file?: CloudFileUpdateOneRequiredWithoutChunksNestedInput
  }

  export type CloudFileChunkUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    fileId?: IntFieldUpdateOperationsInput | number
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkCreateManyInput = {
    id?: number
    fileId: number
    seq: number
    data: Bytes
    createdAt?: Date | string
  }

  export type CloudFileChunkUpdateManyMutationInput = {
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    fileId?: IntFieldUpdateOperationsInput | number
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationCreateInput = {
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
    patient: PatientCreateNestedOneWithoutCommunicationsInput
    user?: UserCreateNestedOneWithoutCommunicationsInput
  }

  export type CommunicationUncheckedCreateInput = {
    id?: number
    patientId: number
    userId?: number | null
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type CommunicationUpdateInput = {
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutCommunicationsNestedInput
    user?: UserUpdateOneWithoutCommunicationsNestedInput
  }

  export type CommunicationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: NullableIntFieldUpdateOperationsInput | number | null
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationCreateManyInput = {
    id?: number
    patientId: number
    userId?: number | null
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type CommunicationUpdateManyMutationInput = {
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: NullableIntFieldUpdateOperationsInput | number | null
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentCreateInput = {
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
    patient: PatientCreateNestedOneWithoutDocumentsInput
  }

  export type PatientDocumentUncheckedCreateInput = {
    id?: number
    patientId: number
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
  }

  export type PatientDocumentUpdateInput = {
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutDocumentsNestedInput
  }

  export type PatientDocumentUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentCreateManyInput = {
    id?: number
    patientId: number
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
  }

  export type PatientDocumentUpdateManyMutationInput = {
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TwilioSettingsCreateInput = {
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage?: string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
    user: UserCreateNestedOneWithoutTwilioSettingsInput
  }

  export type TwilioSettingsUncheckedCreateInput = {
    id?: number
    userId: number
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage?: string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsUpdateInput = {
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
    user?: UserUpdateOneRequiredWithoutTwilioSettingsNestedInput
  }

  export type TwilioSettingsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsCreateManyInput = {
    id?: number
    userId: number
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage?: string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsUpdateManyMutationInput = {
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type AiSettingsCreateInput = {
    apiKey: string
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
    user: UserCreateNestedOneWithoutAiSettingsInput
  }

  export type AiSettingsUncheckedCreateInput = {
    id?: number
    userId: number
    apiKey: string
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
  }

  export type AiSettingsUpdateInput = {
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
    user?: UserUpdateOneRequiredWithoutAiSettingsNestedInput
  }

  export type AiSettingsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
  }

  export type AiSettingsCreateManyInput = {
    id?: number
    userId: number
    apiKey: string
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
  }

  export type AiSettingsUpdateManyMutationInput = {
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
  }

  export type AiSettingsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
  }

  export type OfficeHoursCreateInput = {
    data: JsonNullValueInput | InputJsonValue
    user: UserCreateNestedOneWithoutOfficeHoursInput
  }

  export type OfficeHoursUncheckedCreateInput = {
    id?: number
    userId: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursUpdateInput = {
    data?: JsonNullValueInput | InputJsonValue
    user?: UserUpdateOneRequiredWithoutOfficeHoursNestedInput
  }

  export type OfficeHoursUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursCreateManyInput = {
    id?: number
    userId: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursUpdateManyMutationInput = {
    data?: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type OfficeContactCreateInput = {
    officeName?: string | null
    receptionistName?: string | null
    dentistName?: string | null
    phoneNumber?: string | null
    email?: string | null
    fax?: string | null
    streetAddress?: string | null
    city?: string | null
    state?: string | null
    zipCode?: string | null
    user: UserCreateNestedOneWithoutOfficeContactInput
  }

  export type OfficeContactUncheckedCreateInput = {
    id?: number
    userId: number
    officeName?: string | null
    receptionistName?: string | null
    dentistName?: string | null
    phoneNumber?: string | null
    email?: string | null
    fax?: string | null
    streetAddress?: string | null
    city?: string | null
    state?: string | null
    zipCode?: string | null
  }

  export type OfficeContactUpdateInput = {
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneRequiredWithoutOfficeContactNestedInput
  }

  export type OfficeContactUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OfficeContactCreateManyInput = {
    id?: number
    userId: number
    officeName?: string | null
    receptionistName?: string | null
    dentistName?: string | null
    phoneNumber?: string | null
    email?: string | null
    fax?: string | null
    streetAddress?: string | null
    city?: string | null
    state?: string | null
    zipCode?: string | null
  }

  export type OfficeContactUpdateManyMutationInput = {
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OfficeContactUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type InsuranceContactCreateInput = {
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutInsuranceContactsInput
  }

  export type InsuranceContactUncheckedCreateInput = {
    id?: number
    userId: number
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
  }

  export type InsuranceContactUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutInsuranceContactsNestedInput
  }

  export type InsuranceContactUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type InsuranceContactCreateManyInput = {
    id?: number
    userId: number
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
  }

  export type InsuranceContactUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type InsuranceContactUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProcedureTimeslotCreateInput = {
    data: JsonNullValueInput | InputJsonValue
    user: UserCreateNestedOneWithoutProcedureTimeslotInput
  }

  export type ProcedureTimeslotUncheckedCreateInput = {
    id?: number
    userId: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotUpdateInput = {
    data?: JsonNullValueInput | InputJsonValue
    user?: UserUpdateOneRequiredWithoutProcedureTimeslotNestedInput
  }

  export type ProcedureTimeslotUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotCreateManyInput = {
    id?: number
    userId: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotUpdateManyMutationInput = {
    data?: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type PatientConversationCreateInput = {
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
    patient: PatientCreateNestedOneWithoutConversationInput
    user: UserCreateNestedOneWithoutPatientConversationsInput
  }

  export type PatientConversationUncheckedCreateInput = {
    id?: number
    patientId: number
    userId: number
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
  }

  export type PatientConversationUpdateInput = {
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutConversationNestedInput
    user?: UserUpdateOneRequiredWithoutPatientConversationsNestedInput
  }

  export type PatientConversationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientConversationCreateManyInput = {
    id?: number
    patientId: number
    userId: number
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
  }

  export type PatientConversationUpdateManyMutationInput = {
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientConversationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommissionBatchCreateInput = {
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
    npiProvider: NpiProviderCreateNestedOneWithoutCommissionBatchesInput
    items?: CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput
  }

  export type CommissionBatchUncheckedCreateInput = {
    id?: number
    npiProviderId: number
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
    items?: CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput
  }

  export type CommissionBatchUpdateInput = {
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    npiProvider?: NpiProviderUpdateOneRequiredWithoutCommissionBatchesNestedInput
    items?: CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput
  }

  export type CommissionBatchUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiProviderId?: IntFieldUpdateOperationsInput | number
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput
  }

  export type CommissionBatchCreateManyInput = {
    id?: number
    npiProviderId: number
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
  }

  export type CommissionBatchUpdateManyMutationInput = {
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommissionBatchUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiProviderId?: IntFieldUpdateOperationsInput | number
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommissionBatchItemCreateInput = {
    collectionAmount: Decimal | DecimalJsLike | number | string
    commissionBatch: CommissionBatchCreateNestedOneWithoutItemsInput
    payment: PaymentCreateNestedOneWithoutCommissionBatchItemsInput
  }

  export type CommissionBatchItemUncheckedCreateInput = {
    id?: number
    commissionBatchId: number
    paymentId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUpdateInput = {
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionBatch?: CommissionBatchUpdateOneRequiredWithoutItemsNestedInput
    payment?: PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInput
  }

  export type CommissionBatchItemUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    commissionBatchId?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemCreateManyInput = {
    id?: number
    commissionBatchId: number
    paymentId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUpdateManyMutationInput = {
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    commissionBatchId?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  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 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 BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type PatientListRelationFilter = {
    every?: PatientWhereInput
    some?: PatientWhereInput
    none?: PatientWhereInput
  }

  export type AppointmentListRelationFilter = {
    every?: AppointmentWhereInput
    some?: AppointmentWhereInput
    none?: AppointmentWhereInput
  }

  export type StaffListRelationFilter = {
    every?: StaffWhereInput
    some?: StaffWhereInput
    none?: StaffWhereInput
  }

  export type NpiProviderListRelationFilter = {
    every?: NpiProviderWhereInput
    some?: NpiProviderWhereInput
    none?: NpiProviderWhereInput
  }

  export type ClaimListRelationFilter = {
    every?: ClaimWhereInput
    some?: ClaimWhereInput
    none?: ClaimWhereInput
  }

  export type InsuranceCredentialListRelationFilter = {
    every?: InsuranceCredentialWhereInput
    some?: InsuranceCredentialWhereInput
    none?: InsuranceCredentialWhereInput
  }

  export type ShoppingVendorListRelationFilter = {
    every?: ShoppingVendorWhereInput
    some?: ShoppingVendorWhereInput
    none?: ShoppingVendorWhereInput
  }

  export type PaymentListRelationFilter = {
    every?: PaymentWhereInput
    some?: PaymentWhereInput
    none?: PaymentWhereInput
  }

  export type DatabaseBackupListRelationFilter = {
    every?: DatabaseBackupWhereInput
    some?: DatabaseBackupWhereInput
    none?: DatabaseBackupWhereInput
  }

  export type BackupDestinationListRelationFilter = {
    every?: BackupDestinationWhereInput
    some?: BackupDestinationWhereInput
    none?: BackupDestinationWhereInput
  }

  export type NotificationListRelationFilter = {
    every?: NotificationWhereInput
    some?: NotificationWhereInput
    none?: NotificationWhereInput
  }

  export type CloudFolderListRelationFilter = {
    every?: CloudFolderWhereInput
    some?: CloudFolderWhereInput
    none?: CloudFolderWhereInput
  }

  export type CloudFileListRelationFilter = {
    every?: CloudFileWhereInput
    some?: CloudFileWhereInput
    none?: CloudFileWhereInput
  }

  export type CommunicationListRelationFilter = {
    every?: CommunicationWhereInput
    some?: CommunicationWhereInput
    none?: CommunicationWhereInput
  }

  export type TwilioSettingsNullableScalarRelationFilter = {
    is?: TwilioSettingsWhereInput | null
    isNot?: TwilioSettingsWhereInput | null
  }

  export type AiSettingsNullableScalarRelationFilter = {
    is?: AiSettingsWhereInput | null
    isNot?: AiSettingsWhereInput | null
  }

  export type OfficeHoursNullableScalarRelationFilter = {
    is?: OfficeHoursWhereInput | null
    isNot?: OfficeHoursWhereInput | null
  }

  export type OfficeContactNullableScalarRelationFilter = {
    is?: OfficeContactWhereInput | null
    isNot?: OfficeContactWhereInput | null
  }

  export type ProcedureTimeslotNullableScalarRelationFilter = {
    is?: ProcedureTimeslotWhereInput | null
    isNot?: ProcedureTimeslotWhereInput | null
  }

  export type InsuranceContactListRelationFilter = {
    every?: InsuranceContactWhereInput
    some?: InsuranceContactWhereInput
    none?: InsuranceContactWhereInput
  }

  export type PatientConversationListRelationFilter = {
    every?: PatientConversationWhereInput
    some?: PatientConversationWhereInput
    none?: PatientConversationWhereInput
  }

  export type PatientOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AppointmentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type StaffOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NpiProviderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ClaimOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type InsuranceCredentialOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ShoppingVendorOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PaymentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type DatabaseBackupOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BackupDestinationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NotificationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CloudFolderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CloudFileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CommunicationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type InsuranceContactOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PatientConversationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    autoBackupEnabled?: SortOrder
    usbBackupEnabled?: SortOrder
  }

  export type UserAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    autoBackupEnabled?: SortOrder
    usbBackupEnabled?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    autoBackupEnabled?: SortOrder
    usbBackupEnabled?: SortOrder
  }

  export type UserSumOrderByAggregateInput = {
    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 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 BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  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 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 EnumPatientStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PatientStatus | EnumPatientStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPatientStatusFilter<$PrismaModel> | $Enums.PatientStatus
  }

  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 UserScalarRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type AppointmentProcedureListRelationFilter = {
    every?: AppointmentProcedureWhereInput
    some?: AppointmentProcedureWhereInput
    none?: AppointmentProcedureWhereInput
  }

  export type PdfGroupListRelationFilter = {
    every?: PdfGroupWhereInput
    some?: PdfGroupWhereInput
    none?: PdfGroupWhereInput
  }

  export type PatientDocumentListRelationFilter = {
    every?: PatientDocumentWhereInput
    some?: PatientDocumentWhereInput
    none?: PatientDocumentWhereInput
  }

  export type PatientConversationNullableScalarRelationFilter = {
    is?: PatientConversationWhereInput | null
    isNot?: PatientConversationWhereInput | null
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AppointmentProcedureOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PdfGroupOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PatientDocumentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PatientCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: SortOrder
    gender?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    zipCode?: SortOrder
    insuranceProvider?: SortOrder
    insuranceId?: SortOrder
    groupNumber?: SortOrder
    policyHolder?: SortOrder
    allergies?: SortOrder
    medicalConditions?: SortOrder
    preferredLanguage?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type PatientMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: SortOrder
    gender?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    zipCode?: SortOrder
    insuranceProvider?: SortOrder
    insuranceId?: SortOrder
    groupNumber?: SortOrder
    policyHolder?: SortOrder
    allergies?: SortOrder
    medicalConditions?: SortOrder
    preferredLanguage?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: SortOrder
    gender?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    zipCode?: SortOrder
    insuranceProvider?: SortOrder
    insuranceId?: SortOrder
    groupNumber?: SortOrder
    policyHolder?: SortOrder
    allergies?: SortOrder
    medicalConditions?: SortOrder
    preferredLanguage?: SortOrder
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  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 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 EnumPatientStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PatientStatus | EnumPatientStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPatientStatusWithAggregatesFilter<$PrismaModel> | $Enums.PatientStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPatientStatusFilter<$PrismaModel>
    _max?: NestedEnumPatientStatusFilter<$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 PatientScalarRelationFilter = {
    is?: PatientWhereInput
    isNot?: PatientWhereInput
  }

  export type StaffNullableScalarRelationFilter = {
    is?: StaffWhereInput | null
    isNot?: StaffWhereInput | null
  }

  export type AppointmentFileListRelationFilter = {
    every?: AppointmentFileWhereInput
    some?: AppointmentFileWhereInput
    none?: AppointmentFileWhereInput
  }

  export type AppointmentFileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AppointmentCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    typeLocked?: SortOrder
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: SortOrder
    movedByAi?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
  }

  export type AppointmentAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
  }

  export type AppointmentMaxOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    typeLocked?: SortOrder
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: SortOrder
    movedByAi?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
  }

  export type AppointmentMinOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    typeLocked?: SortOrder
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: SortOrder
    movedByAi?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
  }

  export type AppointmentSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
  }

  export type AppointmentScalarRelationFilter = {
    is?: AppointmentWhereInput
    isNot?: AppointmentWhereInput
  }

  export type AppointmentFileCountOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type AppointmentFileAvgOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
  }

  export type AppointmentFileMaxOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type AppointmentFileMinOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type AppointmentFileSumOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
  }

  export type UserNullableScalarRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type StaffCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    email?: SortOrder
    role?: SortOrder
    phone?: SortOrder
    createdAt?: SortOrder
  }

  export type StaffAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type StaffMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    email?: SortOrder
    role?: SortOrder
    phone?: SortOrder
    createdAt?: SortOrder
  }

  export type StaffMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    email?: SortOrder
    role?: SortOrder
    phone?: SortOrder
    createdAt?: SortOrder
  }

  export type StaffSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type CommissionBatchListRelationFilter = {
    every?: CommissionBatchWhereInput
    some?: CommissionBatchWhereInput
    none?: CommissionBatchWhereInput
  }

  export type CommissionBatchOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NpiProviderUserIdNpiNumberCompoundUniqueInput = {
    userId: number
    npiNumber: string
  }

  export type NpiProviderCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
  }

  export type NpiProviderAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type NpiProviderMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
  }

  export type NpiProviderMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
  }

  export type NpiProviderSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  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 DecimalNullableFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
  }

  export type EnumProcedureSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.ProcedureSource | EnumProcedureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumProcedureSourceFilter<$PrismaModel> | $Enums.ProcedureSource
  }

  export type NpiProviderNullableScalarRelationFilter = {
    is?: NpiProviderWhereInput | null
    isNot?: NpiProviderWhereInput | null
  }

  export type AppointmentProcedureCountOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrder
    procedureCode?: SortOrder
    procedureLabel?: SortOrder
    fee?: SortOrder
    category?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    oralCavityArea?: SortOrder
    source?: SortOrder
    comboKey?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentProcedureAvgOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrder
    fee?: SortOrder
  }

  export type AppointmentProcedureMaxOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrder
    procedureCode?: SortOrder
    procedureLabel?: SortOrder
    fee?: SortOrder
    category?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    oralCavityArea?: SortOrder
    source?: SortOrder
    comboKey?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentProcedureMinOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrder
    procedureCode?: SortOrder
    procedureLabel?: SortOrder
    fee?: SortOrder
    category?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    oralCavityArea?: SortOrder
    source?: SortOrder
    comboKey?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentProcedureSumOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: SortOrder
    npiProviderId?: SortOrder
    fee?: SortOrder
  }

  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 DecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedDecimalNullableFilter<$PrismaModel>
    _sum?: NestedDecimalNullableFilter<$PrismaModel>
    _min?: NestedDecimalNullableFilter<$PrismaModel>
    _max?: NestedDecimalNullableFilter<$PrismaModel>
  }

  export type EnumProcedureSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ProcedureSource | EnumProcedureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumProcedureSourceWithAggregatesFilter<$PrismaModel> | $Enums.ProcedureSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProcedureSourceFilter<$PrismaModel>
    _max?: NestedEnumProcedureSourceFilter<$PrismaModel>
  }

  export type EnumMissingTeethStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.MissingTeethStatus | EnumMissingTeethStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMissingTeethStatusFilter<$PrismaModel> | $Enums.MissingTeethStatus
  }
  export type JsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type EnumClaimStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ClaimStatus | EnumClaimStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumClaimStatusFilter<$PrismaModel> | $Enums.ClaimStatus
  }

  export type AppointmentNullableScalarRelationFilter = {
    is?: AppointmentWhereInput | null
    isNot?: AppointmentWhereInput | null
  }

  export type ServiceLineListRelationFilter = {
    every?: ServiceLineWhereInput
    some?: ServiceLineWhereInput
    none?: ServiceLineWhereInput
  }

  export type ClaimFileListRelationFilter = {
    every?: ClaimFileWhereInput
    some?: ClaimFileWhereInput
    none?: ClaimFileWhereInput
  }

  export type PaymentNullableScalarRelationFilter = {
    is?: PaymentWhereInput | null
    isNot?: PaymentWhereInput | null
  }

  export type ServiceLineOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ClaimFileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ClaimCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    patientName?: SortOrder
    memberId?: SortOrder
    dateOfBirth?: SortOrder
    remarks?: SortOrder
    missingTeethStatus?: SortOrder
    missingTeeth?: SortOrder
    serviceDate?: SortOrder
    insuranceProvider?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    status?: SortOrder
    claimNumber?: SortOrder
    preAuthNumber?: SortOrder
    npiProviderId?: SortOrder
  }

  export type ClaimAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    npiProviderId?: SortOrder
  }

  export type ClaimMaxOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    patientName?: SortOrder
    memberId?: SortOrder
    dateOfBirth?: SortOrder
    remarks?: SortOrder
    missingTeethStatus?: SortOrder
    serviceDate?: SortOrder
    insuranceProvider?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    status?: SortOrder
    claimNumber?: SortOrder
    preAuthNumber?: SortOrder
    npiProviderId?: SortOrder
  }

  export type ClaimMinOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    patientName?: SortOrder
    memberId?: SortOrder
    dateOfBirth?: SortOrder
    remarks?: SortOrder
    missingTeethStatus?: SortOrder
    serviceDate?: SortOrder
    insuranceProvider?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    status?: SortOrder
    claimNumber?: SortOrder
    preAuthNumber?: SortOrder
    npiProviderId?: SortOrder
  }

  export type ClaimSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    npiProviderId?: SortOrder
  }

  export type EnumMissingTeethStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MissingTeethStatus | EnumMissingTeethStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMissingTeethStatusWithAggregatesFilter<$PrismaModel> | $Enums.MissingTeethStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMissingTeethStatusFilter<$PrismaModel>
    _max?: NestedEnumMissingTeethStatusFilter<$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[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | 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 EnumClaimStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ClaimStatus | EnumClaimStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumClaimStatusWithAggregatesFilter<$PrismaModel> | $Enums.ClaimStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumClaimStatusFilter<$PrismaModel>
    _max?: NestedEnumClaimStatusFilter<$PrismaModel>
  }

  export type DecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type EnumServiceLineStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ServiceLineStatus | EnumServiceLineStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumServiceLineStatusFilter<$PrismaModel> | $Enums.ServiceLineStatus
  }

  export type ClaimNullableScalarRelationFilter = {
    is?: ClaimWhereInput | null
    isNot?: ClaimWhereInput | null
  }

  export type ServiceLineTransactionListRelationFilter = {
    every?: ServiceLineTransactionWhereInput
    some?: ServiceLineTransactionWhereInput
    none?: ServiceLineTransactionWhereInput
  }

  export type ServiceLineTransactionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ServiceLineCountOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    procedureCode?: SortOrder
    procedureDate?: SortOrder
    quad?: SortOrder
    arch?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    icn?: SortOrder
    paidCode?: SortOrder
    allowedAmount?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
  }

  export type ServiceLineAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    allowedAmount?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
  }

  export type ServiceLineMaxOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    procedureCode?: SortOrder
    procedureDate?: SortOrder
    quad?: SortOrder
    arch?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    icn?: SortOrder
    paidCode?: SortOrder
    allowedAmount?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
  }

  export type ServiceLineMinOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    procedureCode?: SortOrder
    procedureDate?: SortOrder
    quad?: SortOrder
    arch?: SortOrder
    toothNumber?: SortOrder
    toothSurface?: SortOrder
    icn?: SortOrder
    paidCode?: SortOrder
    allowedAmount?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
  }

  export type ServiceLineSumOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    allowedAmount?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
  }

  export type DecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type EnumServiceLineStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ServiceLineStatus | EnumServiceLineStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumServiceLineStatusWithAggregatesFilter<$PrismaModel> | $Enums.ServiceLineStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumServiceLineStatusFilter<$PrismaModel>
    _max?: NestedEnumServiceLineStatusFilter<$PrismaModel>
  }

  export type ClaimScalarRelationFilter = {
    is?: ClaimWhereInput
    isNot?: ClaimWhereInput
  }

  export type ClaimFileCountOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type ClaimFileAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
  }

  export type ClaimFileMaxOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type ClaimFileMinOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
    filePath?: SortOrder
  }

  export type ClaimFileSumOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
  }

  export type InsuranceCredentialUserIdSiteKeyCompoundUniqueInput = {
    userId: number
    siteKey: string
  }

  export type InsuranceCredentialCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    siteKey?: SortOrder
    username?: SortOrder
    password?: SortOrder
  }

  export type InsuranceCredentialAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type InsuranceCredentialMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    siteKey?: SortOrder
    username?: SortOrder
    password?: SortOrder
  }

  export type InsuranceCredentialMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    siteKey?: SortOrder
    username?: SortOrder
    password?: SortOrder
  }

  export type InsuranceCredentialSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ShoppingVendorCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    vendorName?: SortOrder
    websiteUrl?: SortOrder
    loginUsername?: SortOrder
    loginPassword?: SortOrder
  }

  export type ShoppingVendorAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ShoppingVendorMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    vendorName?: SortOrder
    websiteUrl?: SortOrder
    loginUsername?: SortOrder
    loginPassword?: SortOrder
  }

  export type ShoppingVendorMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    vendorName?: SortOrder
    websiteUrl?: SortOrder
    loginUsername?: SortOrder
    loginPassword?: SortOrder
  }

  export type ShoppingVendorSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type EnumPdfTitleKeyFilter<$PrismaModel = never> = {
    equals?: $Enums.PdfTitleKey | EnumPdfTitleKeyFieldRefInput<$PrismaModel>
    in?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    notIn?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    not?: NestedEnumPdfTitleKeyFilter<$PrismaModel> | $Enums.PdfTitleKey
  }

  export type PdfFileListRelationFilter = {
    every?: PdfFileWhereInput
    some?: PdfFileWhereInput
    none?: PdfFileWhereInput
  }

  export type PdfFileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PdfGroupCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    titleKey?: SortOrder
    createdAt?: SortOrder
    patientId?: SortOrder
  }

  export type PdfGroupAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
  }

  export type PdfGroupMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    titleKey?: SortOrder
    createdAt?: SortOrder
    patientId?: SortOrder
  }

  export type PdfGroupMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    titleKey?: SortOrder
    createdAt?: SortOrder
    patientId?: SortOrder
  }

  export type PdfGroupSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
  }

  export type EnumPdfTitleKeyWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PdfTitleKey | EnumPdfTitleKeyFieldRefInput<$PrismaModel>
    in?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    notIn?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    not?: NestedEnumPdfTitleKeyWithAggregatesFilter<$PrismaModel> | $Enums.PdfTitleKey
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPdfTitleKeyFilter<$PrismaModel>
    _max?: NestedEnumPdfTitleKeyFilter<$PrismaModel>
  }

  export type BytesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesFilter<$PrismaModel> | Bytes
  }

  export type PdfGroupScalarRelationFilter = {
    is?: PdfGroupWhereInput
    isNot?: PdfGroupWhereInput
  }

  export type PdfFileCountOrderByAggregateInput = {
    id?: SortOrder
    filename?: SortOrder
    pdfData?: SortOrder
    uploadedAt?: SortOrder
    groupId?: SortOrder
  }

  export type PdfFileAvgOrderByAggregateInput = {
    id?: SortOrder
    groupId?: SortOrder
  }

  export type PdfFileMaxOrderByAggregateInput = {
    id?: SortOrder
    filename?: SortOrder
    pdfData?: SortOrder
    uploadedAt?: SortOrder
    groupId?: SortOrder
  }

  export type PdfFileMinOrderByAggregateInput = {
    id?: SortOrder
    filename?: SortOrder
    pdfData?: SortOrder
    uploadedAt?: SortOrder
    groupId?: SortOrder
  }

  export type PdfFileSumOrderByAggregateInput = {
    id?: SortOrder
    groupId?: SortOrder
  }

  export type BytesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesWithAggregatesFilter<$PrismaModel> | Bytes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBytesFilter<$PrismaModel>
    _max?: NestedBytesFilter<$PrismaModel>
  }

  export type EnumPaymentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus
  }

  export type CommissionBatchItemListRelationFilter = {
    every?: CommissionBatchItemWhereInput
    some?: CommissionBatchItemWhereInput
    none?: CommissionBatchItemWhereInput
  }

  export type CommissionBatchItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PaymentCountOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    npiProviderId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    npiProviderId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
  }

  export type PaymentMaxOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    npiProviderId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentMinOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    npiProviderId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentSumOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    npiProviderId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    mhPaidAmount?: SortOrder
    copayment?: SortOrder
    adjustment?: SortOrder
  }

  export type EnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentStatusFilter<$PrismaModel>
    _max?: NestedEnumPaymentStatusFilter<$PrismaModel>
  }

  export type EnumPaymentMethodFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentMethod | EnumPaymentMethodFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentMethodFilter<$PrismaModel> | $Enums.PaymentMethod
  }

  export type PaymentScalarRelationFilter = {
    is?: PaymentWhereInput
    isNot?: PaymentWhereInput
  }

  export type ServiceLineScalarRelationFilter = {
    is?: ServiceLineWhereInput
    isNot?: ServiceLineWhereInput
  }

  export type ServiceLineTransactionCountOrderByAggregateInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    transactionId?: SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
    method?: SortOrder
    receivedDate?: SortOrder
    payerName?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type ServiceLineTransactionAvgOrderByAggregateInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
  }

  export type ServiceLineTransactionMaxOrderByAggregateInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    transactionId?: SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
    method?: SortOrder
    receivedDate?: SortOrder
    payerName?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type ServiceLineTransactionMinOrderByAggregateInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    transactionId?: SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
    method?: SortOrder
    receivedDate?: SortOrder
    payerName?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type ServiceLineTransactionSumOrderByAggregateInput = {
    id?: SortOrder
    paymentId?: SortOrder
    serviceLineId?: SortOrder
    paidAmount?: SortOrder
    adjustedAmount?: SortOrder
  }

  export type EnumPaymentMethodWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentMethod | EnumPaymentMethodFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentMethodWithAggregatesFilter<$PrismaModel> | $Enums.PaymentMethod
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentMethodFilter<$PrismaModel>
    _max?: NestedEnumPaymentMethodFilter<$PrismaModel>
  }

  export type DatabaseBackupCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type DatabaseBackupAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type DatabaseBackupMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type DatabaseBackupMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type DatabaseBackupSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type BackupDestinationCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    path?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type BackupDestinationAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type BackupDestinationMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    path?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type BackupDestinationMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    path?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type BackupDestinationSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type EnumNotificationTypesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationTypes | EnumNotificationTypesFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationTypesFilter<$PrismaModel> | $Enums.NotificationTypes
  }

  export type NotificationCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    read?: SortOrder
  }

  export type NotificationAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type NotificationMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    read?: SortOrder
  }

  export type NotificationMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    read?: SortOrder
  }

  export type NotificationSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type EnumNotificationTypesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationTypes | EnumNotificationTypesFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationTypesWithAggregatesFilter<$PrismaModel> | $Enums.NotificationTypes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumNotificationTypesFilter<$PrismaModel>
    _max?: NestedEnumNotificationTypesFilter<$PrismaModel>
  }

  export type CronJobLogCountOrderByAggregateInput = {
    id?: SortOrder
    jobName?: SortOrder
    status?: SortOrder
    startedAt?: SortOrder
    completedAt?: SortOrder
    durationMs?: SortOrder
    errorMessage?: SortOrder
  }

  export type CronJobLogAvgOrderByAggregateInput = {
    id?: SortOrder
    durationMs?: SortOrder
  }

  export type CronJobLogMaxOrderByAggregateInput = {
    id?: SortOrder
    jobName?: SortOrder
    status?: SortOrder
    startedAt?: SortOrder
    completedAt?: SortOrder
    durationMs?: SortOrder
    errorMessage?: SortOrder
  }

  export type CronJobLogMinOrderByAggregateInput = {
    id?: SortOrder
    jobName?: SortOrder
    status?: SortOrder
    startedAt?: SortOrder
    completedAt?: SortOrder
    durationMs?: SortOrder
    errorMessage?: SortOrder
  }

  export type CronJobLogSumOrderByAggregateInput = {
    id?: SortOrder
    durationMs?: SortOrder
  }

  export type CloudFolderNullableScalarRelationFilter = {
    is?: CloudFolderWhereInput | null
    isNot?: CloudFolderWhereInput | null
  }

  export type CloudFolderUserIdParentIdNameCompoundUniqueInput = {
    userId: number
    parentId: number
    name: string
  }

  export type CloudFolderCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    parentId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFolderAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    parentId?: SortOrder
  }

  export type CloudFolderMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    parentId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFolderMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    parentId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFolderSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    parentId?: SortOrder
  }

  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 CloudFileChunkListRelationFilter = {
    every?: CloudFileChunkWhereInput
    some?: CloudFileChunkWhereInput
    none?: CloudFileChunkWhereInput
  }

  export type CloudFileChunkOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CloudFileCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    isComplete?: SortOrder
    totalChunks?: SortOrder
    diskPath?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFileAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    totalChunks?: SortOrder
  }

  export type CloudFileMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    isComplete?: SortOrder
    totalChunks?: SortOrder
    diskPath?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFileMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    isComplete?: SortOrder
    totalChunks?: SortOrder
    diskPath?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFileSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    totalChunks?: 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 CloudFileScalarRelationFilter = {
    is?: CloudFileWhereInput
    isNot?: CloudFileWhereInput
  }

  export type CloudFileChunkFileIdSeqCompoundUniqueInput = {
    fileId: number
    seq: number
  }

  export type CloudFileChunkCountOrderByAggregateInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
    data?: SortOrder
    createdAt?: SortOrder
  }

  export type CloudFileChunkAvgOrderByAggregateInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
  }

  export type CloudFileChunkMaxOrderByAggregateInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
    data?: SortOrder
    createdAt?: SortOrder
  }

  export type CloudFileChunkMinOrderByAggregateInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
    data?: SortOrder
    createdAt?: SortOrder
  }

  export type CloudFileChunkSumOrderByAggregateInput = {
    id?: SortOrder
    fileId?: SortOrder
    seq?: SortOrder
  }

  export type EnumCommunicationChannelFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationChannel | EnumCommunicationChannelFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationChannelFilter<$PrismaModel> | $Enums.CommunicationChannel
  }

  export type EnumCommunicationDirectionFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationDirection | EnumCommunicationDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationDirectionFilter<$PrismaModel> | $Enums.CommunicationDirection
  }

  export type EnumCommunicationStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationStatus | EnumCommunicationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationStatusFilter<$PrismaModel> | $Enums.CommunicationStatus
  }

  export type CommunicationCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    channel?: SortOrder
    direction?: SortOrder
    status?: SortOrder
    body?: SortOrder
    callDuration?: SortOrder
    twilioSid?: SortOrder
    createdAt?: SortOrder
  }

  export type CommunicationAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    callDuration?: SortOrder
  }

  export type CommunicationMaxOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    channel?: SortOrder
    direction?: SortOrder
    status?: SortOrder
    body?: SortOrder
    callDuration?: SortOrder
    twilioSid?: SortOrder
    createdAt?: SortOrder
  }

  export type CommunicationMinOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    channel?: SortOrder
    direction?: SortOrder
    status?: SortOrder
    body?: SortOrder
    callDuration?: SortOrder
    twilioSid?: SortOrder
    createdAt?: SortOrder
  }

  export type CommunicationSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    callDuration?: SortOrder
  }

  export type EnumCommunicationChannelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationChannel | EnumCommunicationChannelFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationChannelWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationChannel
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationChannelFilter<$PrismaModel>
    _max?: NestedEnumCommunicationChannelFilter<$PrismaModel>
  }

  export type EnumCommunicationDirectionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationDirection | EnumCommunicationDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationDirectionWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationDirection
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationDirectionFilter<$PrismaModel>
    _max?: NestedEnumCommunicationDirectionFilter<$PrismaModel>
  }

  export type EnumCommunicationStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationStatus | EnumCommunicationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationStatusWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationStatusFilter<$PrismaModel>
    _max?: NestedEnumCommunicationStatusFilter<$PrismaModel>
  }

  export type PatientDocumentCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    filename?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    filePath?: SortOrder
    uploadedAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientDocumentAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    fileSize?: SortOrder
  }

  export type PatientDocumentMaxOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    filename?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    filePath?: SortOrder
    uploadedAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientDocumentMinOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    filename?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    filePath?: SortOrder
    uploadedAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientDocumentSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    fileSize?: SortOrder
  }

  export type TwilioSettingsCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    accountSid?: SortOrder
    authToken?: SortOrder
    phoneNumber?: SortOrder
    greetingMessage?: SortOrder
    templates?: SortOrder
  }

  export type TwilioSettingsAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type TwilioSettingsMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    accountSid?: SortOrder
    authToken?: SortOrder
    phoneNumber?: SortOrder
    greetingMessage?: SortOrder
  }

  export type TwilioSettingsMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    accountSid?: SortOrder
    authToken?: SortOrder
    phoneNumber?: SortOrder
    greetingMessage?: SortOrder
  }

  export type TwilioSettingsSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type AiSettingsCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    apiKey?: SortOrder
    afterHoursEnabled?: SortOrder
    openPhoneReply?: SortOrder
  }

  export type AiSettingsAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type AiSettingsMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    apiKey?: SortOrder
    afterHoursEnabled?: SortOrder
    openPhoneReply?: SortOrder
  }

  export type AiSettingsMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    apiKey?: SortOrder
    afterHoursEnabled?: SortOrder
    openPhoneReply?: SortOrder
  }

  export type AiSettingsSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: 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[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type OfficeHoursCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
  }

  export type OfficeHoursAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type OfficeHoursMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type OfficeHoursMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type OfficeHoursSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: 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[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | 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 OfficeContactCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    officeName?: SortOrder
    receptionistName?: SortOrder
    dentistName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    fax?: SortOrder
    streetAddress?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
  }

  export type OfficeContactAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type OfficeContactMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    officeName?: SortOrder
    receptionistName?: SortOrder
    dentistName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    fax?: SortOrder
    streetAddress?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
  }

  export type OfficeContactMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    officeName?: SortOrder
    receptionistName?: SortOrder
    dentistName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    fax?: SortOrder
    streetAddress?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
  }

  export type OfficeContactSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type InsuranceContactCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    phoneNumber?: SortOrder
    createdAt?: SortOrder
  }

  export type InsuranceContactAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type InsuranceContactMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    phoneNumber?: SortOrder
    createdAt?: SortOrder
  }

  export type InsuranceContactMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    phoneNumber?: SortOrder
    createdAt?: SortOrder
  }

  export type InsuranceContactSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ProcedureTimeslotCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    data?: SortOrder
  }

  export type ProcedureTimeslotAvgOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ProcedureTimeslotMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ProcedureTimeslotMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type ProcedureTimeslotSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  export type PatientConversationCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    stage?: SortOrder
    aiHandoff?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientConversationAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
  }

  export type PatientConversationMaxOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    stage?: SortOrder
    aiHandoff?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientConversationMinOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    stage?: SortOrder
    aiHandoff?: SortOrder
    updatedAt?: SortOrder
  }

  export type PatientConversationSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
  }

  export type NpiProviderScalarRelationFilter = {
    is?: NpiProviderWhereInput
    isNot?: NpiProviderWhereInput
  }

  export type CommissionBatchCountOrderByAggregateInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type CommissionBatchAvgOrderByAggregateInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
  }

  export type CommissionBatchMaxOrderByAggregateInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type CommissionBatchMinOrderByAggregateInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
    notes?: SortOrder
    createdAt?: SortOrder
  }

  export type CommissionBatchSumOrderByAggregateInput = {
    id?: SortOrder
    npiProviderId?: SortOrder
    totalCollection?: SortOrder
    commissionAmount?: SortOrder
  }

  export type CommissionBatchScalarRelationFilter = {
    is?: CommissionBatchWhereInput
    isNot?: CommissionBatchWhereInput
  }

  export type CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput = {
    commissionBatchId: number
    paymentId: number
  }

  export type CommissionBatchItemCountOrderByAggregateInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
  }

  export type CommissionBatchItemAvgOrderByAggregateInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
  }

  export type CommissionBatchItemMaxOrderByAggregateInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
  }

  export type CommissionBatchItemMinOrderByAggregateInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
  }

  export type CommissionBatchItemSumOrderByAggregateInput = {
    id?: SortOrder
    commissionBatchId?: SortOrder
    paymentId?: SortOrder
    collectionAmount?: SortOrder
  }

  export type PatientCreateNestedManyWithoutUserInput = {
    create?: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput> | PatientCreateWithoutUserInput[] | PatientUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientCreateOrConnectWithoutUserInput | PatientCreateOrConnectWithoutUserInput[]
    createMany?: PatientCreateManyUserInputEnvelope
    connect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
  }

  export type AppointmentCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput> | AppointmentCreateWithoutUserInput[] | AppointmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutUserInput | AppointmentCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentCreateManyUserInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type StaffCreateNestedManyWithoutUserInput = {
    create?: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput> | StaffCreateWithoutUserInput[] | StaffUncheckedCreateWithoutUserInput[]
    connectOrCreate?: StaffCreateOrConnectWithoutUserInput | StaffCreateOrConnectWithoutUserInput[]
    createMany?: StaffCreateManyUserInputEnvelope
    connect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
  }

  export type NpiProviderCreateNestedManyWithoutUserInput = {
    create?: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput> | NpiProviderCreateWithoutUserInput[] | NpiProviderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NpiProviderCreateOrConnectWithoutUserInput | NpiProviderCreateOrConnectWithoutUserInput[]
    createMany?: NpiProviderCreateManyUserInputEnvelope
    connect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
  }

  export type ClaimCreateNestedManyWithoutUserInput = {
    create?: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput> | ClaimCreateWithoutUserInput[] | ClaimUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutUserInput | ClaimCreateOrConnectWithoutUserInput[]
    createMany?: ClaimCreateManyUserInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type InsuranceCredentialCreateNestedManyWithoutUserInput = {
    create?: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput> | InsuranceCredentialCreateWithoutUserInput[] | InsuranceCredentialUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceCredentialCreateOrConnectWithoutUserInput | InsuranceCredentialCreateOrConnectWithoutUserInput[]
    createMany?: InsuranceCredentialCreateManyUserInputEnvelope
    connect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
  }

  export type ShoppingVendorCreateNestedManyWithoutUserInput = {
    create?: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput> | ShoppingVendorCreateWithoutUserInput[] | ShoppingVendorUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ShoppingVendorCreateOrConnectWithoutUserInput | ShoppingVendorCreateOrConnectWithoutUserInput[]
    createMany?: ShoppingVendorCreateManyUserInputEnvelope
    connect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
  }

  export type PaymentCreateNestedManyWithoutUpdatedByInput = {
    create?: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput> | PaymentCreateWithoutUpdatedByInput[] | PaymentUncheckedCreateWithoutUpdatedByInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUpdatedByInput | PaymentCreateOrConnectWithoutUpdatedByInput[]
    createMany?: PaymentCreateManyUpdatedByInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type DatabaseBackupCreateNestedManyWithoutUserInput = {
    create?: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput> | DatabaseBackupCreateWithoutUserInput[] | DatabaseBackupUncheckedCreateWithoutUserInput[]
    connectOrCreate?: DatabaseBackupCreateOrConnectWithoutUserInput | DatabaseBackupCreateOrConnectWithoutUserInput[]
    createMany?: DatabaseBackupCreateManyUserInputEnvelope
    connect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
  }

  export type BackupDestinationCreateNestedManyWithoutUserInput = {
    create?: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput> | BackupDestinationCreateWithoutUserInput[] | BackupDestinationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: BackupDestinationCreateOrConnectWithoutUserInput | BackupDestinationCreateOrConnectWithoutUserInput[]
    createMany?: BackupDestinationCreateManyUserInputEnvelope
    connect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
  }

  export type NotificationCreateNestedManyWithoutUserInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type CloudFolderCreateNestedManyWithoutUserInput = {
    create?: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput> | CloudFolderCreateWithoutUserInput[] | CloudFolderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutUserInput | CloudFolderCreateOrConnectWithoutUserInput[]
    createMany?: CloudFolderCreateManyUserInputEnvelope
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
  }

  export type CloudFileCreateNestedManyWithoutUserInput = {
    create?: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput> | CloudFileCreateWithoutUserInput[] | CloudFileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutUserInput | CloudFileCreateOrConnectWithoutUserInput[]
    createMany?: CloudFileCreateManyUserInputEnvelope
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
  }

  export type CommunicationCreateNestedManyWithoutUserInput = {
    create?: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput> | CommunicationCreateWithoutUserInput[] | CommunicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutUserInput | CommunicationCreateOrConnectWithoutUserInput[]
    createMany?: CommunicationCreateManyUserInputEnvelope
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
  }

  export type TwilioSettingsCreateNestedOneWithoutUserInput = {
    create?: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: TwilioSettingsCreateOrConnectWithoutUserInput
    connect?: TwilioSettingsWhereUniqueInput
  }

  export type AiSettingsCreateNestedOneWithoutUserInput = {
    create?: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AiSettingsCreateOrConnectWithoutUserInput
    connect?: AiSettingsWhereUniqueInput
  }

  export type OfficeHoursCreateNestedOneWithoutUserInput = {
    create?: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeHoursCreateOrConnectWithoutUserInput
    connect?: OfficeHoursWhereUniqueInput
  }

  export type OfficeContactCreateNestedOneWithoutUserInput = {
    create?: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeContactCreateOrConnectWithoutUserInput
    connect?: OfficeContactWhereUniqueInput
  }

  export type ProcedureTimeslotCreateNestedOneWithoutUserInput = {
    create?: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProcedureTimeslotCreateOrConnectWithoutUserInput
    connect?: ProcedureTimeslotWhereUniqueInput
  }

  export type InsuranceContactCreateNestedManyWithoutUserInput = {
    create?: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput> | InsuranceContactCreateWithoutUserInput[] | InsuranceContactUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceContactCreateOrConnectWithoutUserInput | InsuranceContactCreateOrConnectWithoutUserInput[]
    createMany?: InsuranceContactCreateManyUserInputEnvelope
    connect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
  }

  export type PatientConversationCreateNestedManyWithoutUserInput = {
    create?: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput> | PatientConversationCreateWithoutUserInput[] | PatientConversationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientConversationCreateOrConnectWithoutUserInput | PatientConversationCreateOrConnectWithoutUserInput[]
    createMany?: PatientConversationCreateManyUserInputEnvelope
    connect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
  }

  export type PatientUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput> | PatientCreateWithoutUserInput[] | PatientUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientCreateOrConnectWithoutUserInput | PatientCreateOrConnectWithoutUserInput[]
    createMany?: PatientCreateManyUserInputEnvelope
    connect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
  }

  export type AppointmentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput> | AppointmentCreateWithoutUserInput[] | AppointmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutUserInput | AppointmentCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentCreateManyUserInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type StaffUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput> | StaffCreateWithoutUserInput[] | StaffUncheckedCreateWithoutUserInput[]
    connectOrCreate?: StaffCreateOrConnectWithoutUserInput | StaffCreateOrConnectWithoutUserInput[]
    createMany?: StaffCreateManyUserInputEnvelope
    connect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
  }

  export type NpiProviderUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput> | NpiProviderCreateWithoutUserInput[] | NpiProviderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NpiProviderCreateOrConnectWithoutUserInput | NpiProviderCreateOrConnectWithoutUserInput[]
    createMany?: NpiProviderCreateManyUserInputEnvelope
    connect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
  }

  export type ClaimUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput> | ClaimCreateWithoutUserInput[] | ClaimUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutUserInput | ClaimCreateOrConnectWithoutUserInput[]
    createMany?: ClaimCreateManyUserInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput> | InsuranceCredentialCreateWithoutUserInput[] | InsuranceCredentialUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceCredentialCreateOrConnectWithoutUserInput | InsuranceCredentialCreateOrConnectWithoutUserInput[]
    createMany?: InsuranceCredentialCreateManyUserInputEnvelope
    connect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
  }

  export type ShoppingVendorUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput> | ShoppingVendorCreateWithoutUserInput[] | ShoppingVendorUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ShoppingVendorCreateOrConnectWithoutUserInput | ShoppingVendorCreateOrConnectWithoutUserInput[]
    createMany?: ShoppingVendorCreateManyUserInputEnvelope
    connect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedManyWithoutUpdatedByInput = {
    create?: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput> | PaymentCreateWithoutUpdatedByInput[] | PaymentUncheckedCreateWithoutUpdatedByInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUpdatedByInput | PaymentCreateOrConnectWithoutUpdatedByInput[]
    createMany?: PaymentCreateManyUpdatedByInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type DatabaseBackupUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput> | DatabaseBackupCreateWithoutUserInput[] | DatabaseBackupUncheckedCreateWithoutUserInput[]
    connectOrCreate?: DatabaseBackupCreateOrConnectWithoutUserInput | DatabaseBackupCreateOrConnectWithoutUserInput[]
    createMany?: DatabaseBackupCreateManyUserInputEnvelope
    connect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
  }

  export type BackupDestinationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput> | BackupDestinationCreateWithoutUserInput[] | BackupDestinationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: BackupDestinationCreateOrConnectWithoutUserInput | BackupDestinationCreateOrConnectWithoutUserInput[]
    createMany?: BackupDestinationCreateManyUserInputEnvelope
    connect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type CloudFolderUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput> | CloudFolderCreateWithoutUserInput[] | CloudFolderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutUserInput | CloudFolderCreateOrConnectWithoutUserInput[]
    createMany?: CloudFolderCreateManyUserInputEnvelope
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
  }

  export type CloudFileUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput> | CloudFileCreateWithoutUserInput[] | CloudFileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutUserInput | CloudFileCreateOrConnectWithoutUserInput[]
    createMany?: CloudFileCreateManyUserInputEnvelope
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
  }

  export type CommunicationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput> | CommunicationCreateWithoutUserInput[] | CommunicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutUserInput | CommunicationCreateOrConnectWithoutUserInput[]
    createMany?: CommunicationCreateManyUserInputEnvelope
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
  }

  export type TwilioSettingsUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: TwilioSettingsCreateOrConnectWithoutUserInput
    connect?: TwilioSettingsWhereUniqueInput
  }

  export type AiSettingsUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AiSettingsCreateOrConnectWithoutUserInput
    connect?: AiSettingsWhereUniqueInput
  }

  export type OfficeHoursUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeHoursCreateOrConnectWithoutUserInput
    connect?: OfficeHoursWhereUniqueInput
  }

  export type OfficeContactUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeContactCreateOrConnectWithoutUserInput
    connect?: OfficeContactWhereUniqueInput
  }

  export type ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProcedureTimeslotCreateOrConnectWithoutUserInput
    connect?: ProcedureTimeslotWhereUniqueInput
  }

  export type InsuranceContactUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput> | InsuranceContactCreateWithoutUserInput[] | InsuranceContactUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceContactCreateOrConnectWithoutUserInput | InsuranceContactCreateOrConnectWithoutUserInput[]
    createMany?: InsuranceContactCreateManyUserInputEnvelope
    connect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
  }

  export type PatientConversationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput> | PatientConversationCreateWithoutUserInput[] | PatientConversationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientConversationCreateOrConnectWithoutUserInput | PatientConversationCreateOrConnectWithoutUserInput[]
    createMany?: PatientConversationCreateManyUserInputEnvelope
    connect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type PatientUpdateManyWithoutUserNestedInput = {
    create?: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput> | PatientCreateWithoutUserInput[] | PatientUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientCreateOrConnectWithoutUserInput | PatientCreateOrConnectWithoutUserInput[]
    upsert?: PatientUpsertWithWhereUniqueWithoutUserInput | PatientUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PatientCreateManyUserInputEnvelope
    set?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    disconnect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    delete?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    connect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    update?: PatientUpdateWithWhereUniqueWithoutUserInput | PatientUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PatientUpdateManyWithWhereWithoutUserInput | PatientUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PatientScalarWhereInput | PatientScalarWhereInput[]
  }

  export type AppointmentUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput> | AppointmentCreateWithoutUserInput[] | AppointmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutUserInput | AppointmentCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutUserInput | AppointmentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentCreateManyUserInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutUserInput | AppointmentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutUserInput | AppointmentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type StaffUpdateManyWithoutUserNestedInput = {
    create?: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput> | StaffCreateWithoutUserInput[] | StaffUncheckedCreateWithoutUserInput[]
    connectOrCreate?: StaffCreateOrConnectWithoutUserInput | StaffCreateOrConnectWithoutUserInput[]
    upsert?: StaffUpsertWithWhereUniqueWithoutUserInput | StaffUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: StaffCreateManyUserInputEnvelope
    set?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    disconnect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    delete?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    connect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    update?: StaffUpdateWithWhereUniqueWithoutUserInput | StaffUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: StaffUpdateManyWithWhereWithoutUserInput | StaffUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: StaffScalarWhereInput | StaffScalarWhereInput[]
  }

  export type NpiProviderUpdateManyWithoutUserNestedInput = {
    create?: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput> | NpiProviderCreateWithoutUserInput[] | NpiProviderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NpiProviderCreateOrConnectWithoutUserInput | NpiProviderCreateOrConnectWithoutUserInput[]
    upsert?: NpiProviderUpsertWithWhereUniqueWithoutUserInput | NpiProviderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NpiProviderCreateManyUserInputEnvelope
    set?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    disconnect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    delete?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    connect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    update?: NpiProviderUpdateWithWhereUniqueWithoutUserInput | NpiProviderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NpiProviderUpdateManyWithWhereWithoutUserInput | NpiProviderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NpiProviderScalarWhereInput | NpiProviderScalarWhereInput[]
  }

  export type ClaimUpdateManyWithoutUserNestedInput = {
    create?: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput> | ClaimCreateWithoutUserInput[] | ClaimUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutUserInput | ClaimCreateOrConnectWithoutUserInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutUserInput | ClaimUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ClaimCreateManyUserInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutUserInput | ClaimUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutUserInput | ClaimUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type InsuranceCredentialUpdateManyWithoutUserNestedInput = {
    create?: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput> | InsuranceCredentialCreateWithoutUserInput[] | InsuranceCredentialUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceCredentialCreateOrConnectWithoutUserInput | InsuranceCredentialCreateOrConnectWithoutUserInput[]
    upsert?: InsuranceCredentialUpsertWithWhereUniqueWithoutUserInput | InsuranceCredentialUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: InsuranceCredentialCreateManyUserInputEnvelope
    set?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    disconnect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    delete?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    connect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    update?: InsuranceCredentialUpdateWithWhereUniqueWithoutUserInput | InsuranceCredentialUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: InsuranceCredentialUpdateManyWithWhereWithoutUserInput | InsuranceCredentialUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: InsuranceCredentialScalarWhereInput | InsuranceCredentialScalarWhereInput[]
  }

  export type ShoppingVendorUpdateManyWithoutUserNestedInput = {
    create?: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput> | ShoppingVendorCreateWithoutUserInput[] | ShoppingVendorUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ShoppingVendorCreateOrConnectWithoutUserInput | ShoppingVendorCreateOrConnectWithoutUserInput[]
    upsert?: ShoppingVendorUpsertWithWhereUniqueWithoutUserInput | ShoppingVendorUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ShoppingVendorCreateManyUserInputEnvelope
    set?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    disconnect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    delete?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    connect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    update?: ShoppingVendorUpdateWithWhereUniqueWithoutUserInput | ShoppingVendorUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ShoppingVendorUpdateManyWithWhereWithoutUserInput | ShoppingVendorUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ShoppingVendorScalarWhereInput | ShoppingVendorScalarWhereInput[]
  }

  export type PaymentUpdateManyWithoutUpdatedByNestedInput = {
    create?: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput> | PaymentCreateWithoutUpdatedByInput[] | PaymentUncheckedCreateWithoutUpdatedByInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUpdatedByInput | PaymentCreateOrConnectWithoutUpdatedByInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutUpdatedByInput | PaymentUpsertWithWhereUniqueWithoutUpdatedByInput[]
    createMany?: PaymentCreateManyUpdatedByInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutUpdatedByInput | PaymentUpdateWithWhereUniqueWithoutUpdatedByInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutUpdatedByInput | PaymentUpdateManyWithWhereWithoutUpdatedByInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type DatabaseBackupUpdateManyWithoutUserNestedInput = {
    create?: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput> | DatabaseBackupCreateWithoutUserInput[] | DatabaseBackupUncheckedCreateWithoutUserInput[]
    connectOrCreate?: DatabaseBackupCreateOrConnectWithoutUserInput | DatabaseBackupCreateOrConnectWithoutUserInput[]
    upsert?: DatabaseBackupUpsertWithWhereUniqueWithoutUserInput | DatabaseBackupUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: DatabaseBackupCreateManyUserInputEnvelope
    set?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    disconnect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    delete?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    connect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    update?: DatabaseBackupUpdateWithWhereUniqueWithoutUserInput | DatabaseBackupUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: DatabaseBackupUpdateManyWithWhereWithoutUserInput | DatabaseBackupUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: DatabaseBackupScalarWhereInput | DatabaseBackupScalarWhereInput[]
  }

  export type BackupDestinationUpdateManyWithoutUserNestedInput = {
    create?: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput> | BackupDestinationCreateWithoutUserInput[] | BackupDestinationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: BackupDestinationCreateOrConnectWithoutUserInput | BackupDestinationCreateOrConnectWithoutUserInput[]
    upsert?: BackupDestinationUpsertWithWhereUniqueWithoutUserInput | BackupDestinationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: BackupDestinationCreateManyUserInputEnvelope
    set?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    disconnect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    delete?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    connect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    update?: BackupDestinationUpdateWithWhereUniqueWithoutUserInput | BackupDestinationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: BackupDestinationUpdateManyWithWhereWithoutUserInput | BackupDestinationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: BackupDestinationScalarWhereInput | BackupDestinationScalarWhereInput[]
  }

  export type NotificationUpdateManyWithoutUserNestedInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutUserInput | NotificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutUserInput | NotificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutUserInput | NotificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type CloudFolderUpdateManyWithoutUserNestedInput = {
    create?: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput> | CloudFolderCreateWithoutUserInput[] | CloudFolderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutUserInput | CloudFolderCreateOrConnectWithoutUserInput[]
    upsert?: CloudFolderUpsertWithWhereUniqueWithoutUserInput | CloudFolderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CloudFolderCreateManyUserInputEnvelope
    set?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    disconnect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    delete?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    update?: CloudFolderUpdateWithWhereUniqueWithoutUserInput | CloudFolderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CloudFolderUpdateManyWithWhereWithoutUserInput | CloudFolderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
  }

  export type CloudFileUpdateManyWithoutUserNestedInput = {
    create?: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput> | CloudFileCreateWithoutUserInput[] | CloudFileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutUserInput | CloudFileCreateOrConnectWithoutUserInput[]
    upsert?: CloudFileUpsertWithWhereUniqueWithoutUserInput | CloudFileUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CloudFileCreateManyUserInputEnvelope
    set?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    disconnect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    delete?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    update?: CloudFileUpdateWithWhereUniqueWithoutUserInput | CloudFileUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CloudFileUpdateManyWithWhereWithoutUserInput | CloudFileUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
  }

  export type CommunicationUpdateManyWithoutUserNestedInput = {
    create?: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput> | CommunicationCreateWithoutUserInput[] | CommunicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutUserInput | CommunicationCreateOrConnectWithoutUserInput[]
    upsert?: CommunicationUpsertWithWhereUniqueWithoutUserInput | CommunicationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CommunicationCreateManyUserInputEnvelope
    set?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    disconnect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    delete?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    update?: CommunicationUpdateWithWhereUniqueWithoutUserInput | CommunicationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CommunicationUpdateManyWithWhereWithoutUserInput | CommunicationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
  }

  export type TwilioSettingsUpdateOneWithoutUserNestedInput = {
    create?: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: TwilioSettingsCreateOrConnectWithoutUserInput
    upsert?: TwilioSettingsUpsertWithoutUserInput
    disconnect?: TwilioSettingsWhereInput | boolean
    delete?: TwilioSettingsWhereInput | boolean
    connect?: TwilioSettingsWhereUniqueInput
    update?: XOR<XOR<TwilioSettingsUpdateToOneWithWhereWithoutUserInput, TwilioSettingsUpdateWithoutUserInput>, TwilioSettingsUncheckedUpdateWithoutUserInput>
  }

  export type AiSettingsUpdateOneWithoutUserNestedInput = {
    create?: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AiSettingsCreateOrConnectWithoutUserInput
    upsert?: AiSettingsUpsertWithoutUserInput
    disconnect?: AiSettingsWhereInput | boolean
    delete?: AiSettingsWhereInput | boolean
    connect?: AiSettingsWhereUniqueInput
    update?: XOR<XOR<AiSettingsUpdateToOneWithWhereWithoutUserInput, AiSettingsUpdateWithoutUserInput>, AiSettingsUncheckedUpdateWithoutUserInput>
  }

  export type OfficeHoursUpdateOneWithoutUserNestedInput = {
    create?: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeHoursCreateOrConnectWithoutUserInput
    upsert?: OfficeHoursUpsertWithoutUserInput
    disconnect?: OfficeHoursWhereInput | boolean
    delete?: OfficeHoursWhereInput | boolean
    connect?: OfficeHoursWhereUniqueInput
    update?: XOR<XOR<OfficeHoursUpdateToOneWithWhereWithoutUserInput, OfficeHoursUpdateWithoutUserInput>, OfficeHoursUncheckedUpdateWithoutUserInput>
  }

  export type OfficeContactUpdateOneWithoutUserNestedInput = {
    create?: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeContactCreateOrConnectWithoutUserInput
    upsert?: OfficeContactUpsertWithoutUserInput
    disconnect?: OfficeContactWhereInput | boolean
    delete?: OfficeContactWhereInput | boolean
    connect?: OfficeContactWhereUniqueInput
    update?: XOR<XOR<OfficeContactUpdateToOneWithWhereWithoutUserInput, OfficeContactUpdateWithoutUserInput>, OfficeContactUncheckedUpdateWithoutUserInput>
  }

  export type ProcedureTimeslotUpdateOneWithoutUserNestedInput = {
    create?: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProcedureTimeslotCreateOrConnectWithoutUserInput
    upsert?: ProcedureTimeslotUpsertWithoutUserInput
    disconnect?: ProcedureTimeslotWhereInput | boolean
    delete?: ProcedureTimeslotWhereInput | boolean
    connect?: ProcedureTimeslotWhereUniqueInput
    update?: XOR<XOR<ProcedureTimeslotUpdateToOneWithWhereWithoutUserInput, ProcedureTimeslotUpdateWithoutUserInput>, ProcedureTimeslotUncheckedUpdateWithoutUserInput>
  }

  export type InsuranceContactUpdateManyWithoutUserNestedInput = {
    create?: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput> | InsuranceContactCreateWithoutUserInput[] | InsuranceContactUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceContactCreateOrConnectWithoutUserInput | InsuranceContactCreateOrConnectWithoutUserInput[]
    upsert?: InsuranceContactUpsertWithWhereUniqueWithoutUserInput | InsuranceContactUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: InsuranceContactCreateManyUserInputEnvelope
    set?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    disconnect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    delete?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    connect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    update?: InsuranceContactUpdateWithWhereUniqueWithoutUserInput | InsuranceContactUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: InsuranceContactUpdateManyWithWhereWithoutUserInput | InsuranceContactUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: InsuranceContactScalarWhereInput | InsuranceContactScalarWhereInput[]
  }

  export type PatientConversationUpdateManyWithoutUserNestedInput = {
    create?: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput> | PatientConversationCreateWithoutUserInput[] | PatientConversationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientConversationCreateOrConnectWithoutUserInput | PatientConversationCreateOrConnectWithoutUserInput[]
    upsert?: PatientConversationUpsertWithWhereUniqueWithoutUserInput | PatientConversationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PatientConversationCreateManyUserInputEnvelope
    set?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    disconnect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    delete?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    connect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    update?: PatientConversationUpdateWithWhereUniqueWithoutUserInput | PatientConversationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PatientConversationUpdateManyWithWhereWithoutUserInput | PatientConversationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PatientConversationScalarWhereInput | PatientConversationScalarWhereInput[]
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type PatientUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput> | PatientCreateWithoutUserInput[] | PatientUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientCreateOrConnectWithoutUserInput | PatientCreateOrConnectWithoutUserInput[]
    upsert?: PatientUpsertWithWhereUniqueWithoutUserInput | PatientUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PatientCreateManyUserInputEnvelope
    set?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    disconnect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    delete?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    connect?: PatientWhereUniqueInput | PatientWhereUniqueInput[]
    update?: PatientUpdateWithWhereUniqueWithoutUserInput | PatientUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PatientUpdateManyWithWhereWithoutUserInput | PatientUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PatientScalarWhereInput | PatientScalarWhereInput[]
  }

  export type AppointmentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput> | AppointmentCreateWithoutUserInput[] | AppointmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutUserInput | AppointmentCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutUserInput | AppointmentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentCreateManyUserInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutUserInput | AppointmentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutUserInput | AppointmentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type StaffUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput> | StaffCreateWithoutUserInput[] | StaffUncheckedCreateWithoutUserInput[]
    connectOrCreate?: StaffCreateOrConnectWithoutUserInput | StaffCreateOrConnectWithoutUserInput[]
    upsert?: StaffUpsertWithWhereUniqueWithoutUserInput | StaffUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: StaffCreateManyUserInputEnvelope
    set?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    disconnect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    delete?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    connect?: StaffWhereUniqueInput | StaffWhereUniqueInput[]
    update?: StaffUpdateWithWhereUniqueWithoutUserInput | StaffUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: StaffUpdateManyWithWhereWithoutUserInput | StaffUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: StaffScalarWhereInput | StaffScalarWhereInput[]
  }

  export type NpiProviderUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput> | NpiProviderCreateWithoutUserInput[] | NpiProviderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NpiProviderCreateOrConnectWithoutUserInput | NpiProviderCreateOrConnectWithoutUserInput[]
    upsert?: NpiProviderUpsertWithWhereUniqueWithoutUserInput | NpiProviderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NpiProviderCreateManyUserInputEnvelope
    set?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    disconnect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    delete?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    connect?: NpiProviderWhereUniqueInput | NpiProviderWhereUniqueInput[]
    update?: NpiProviderUpdateWithWhereUniqueWithoutUserInput | NpiProviderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NpiProviderUpdateManyWithWhereWithoutUserInput | NpiProviderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NpiProviderScalarWhereInput | NpiProviderScalarWhereInput[]
  }

  export type ClaimUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput> | ClaimCreateWithoutUserInput[] | ClaimUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutUserInput | ClaimCreateOrConnectWithoutUserInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutUserInput | ClaimUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ClaimCreateManyUserInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutUserInput | ClaimUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutUserInput | ClaimUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput> | InsuranceCredentialCreateWithoutUserInput[] | InsuranceCredentialUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceCredentialCreateOrConnectWithoutUserInput | InsuranceCredentialCreateOrConnectWithoutUserInput[]
    upsert?: InsuranceCredentialUpsertWithWhereUniqueWithoutUserInput | InsuranceCredentialUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: InsuranceCredentialCreateManyUserInputEnvelope
    set?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    disconnect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    delete?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    connect?: InsuranceCredentialWhereUniqueInput | InsuranceCredentialWhereUniqueInput[]
    update?: InsuranceCredentialUpdateWithWhereUniqueWithoutUserInput | InsuranceCredentialUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: InsuranceCredentialUpdateManyWithWhereWithoutUserInput | InsuranceCredentialUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: InsuranceCredentialScalarWhereInput | InsuranceCredentialScalarWhereInput[]
  }

  export type ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput> | ShoppingVendorCreateWithoutUserInput[] | ShoppingVendorUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ShoppingVendorCreateOrConnectWithoutUserInput | ShoppingVendorCreateOrConnectWithoutUserInput[]
    upsert?: ShoppingVendorUpsertWithWhereUniqueWithoutUserInput | ShoppingVendorUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ShoppingVendorCreateManyUserInputEnvelope
    set?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    disconnect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    delete?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    connect?: ShoppingVendorWhereUniqueInput | ShoppingVendorWhereUniqueInput[]
    update?: ShoppingVendorUpdateWithWhereUniqueWithoutUserInput | ShoppingVendorUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ShoppingVendorUpdateManyWithWhereWithoutUserInput | ShoppingVendorUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ShoppingVendorScalarWhereInput | ShoppingVendorScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput = {
    create?: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput> | PaymentCreateWithoutUpdatedByInput[] | PaymentUncheckedCreateWithoutUpdatedByInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUpdatedByInput | PaymentCreateOrConnectWithoutUpdatedByInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutUpdatedByInput | PaymentUpsertWithWhereUniqueWithoutUpdatedByInput[]
    createMany?: PaymentCreateManyUpdatedByInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutUpdatedByInput | PaymentUpdateWithWhereUniqueWithoutUpdatedByInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutUpdatedByInput | PaymentUpdateManyWithWhereWithoutUpdatedByInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput> | DatabaseBackupCreateWithoutUserInput[] | DatabaseBackupUncheckedCreateWithoutUserInput[]
    connectOrCreate?: DatabaseBackupCreateOrConnectWithoutUserInput | DatabaseBackupCreateOrConnectWithoutUserInput[]
    upsert?: DatabaseBackupUpsertWithWhereUniqueWithoutUserInput | DatabaseBackupUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: DatabaseBackupCreateManyUserInputEnvelope
    set?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    disconnect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    delete?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    connect?: DatabaseBackupWhereUniqueInput | DatabaseBackupWhereUniqueInput[]
    update?: DatabaseBackupUpdateWithWhereUniqueWithoutUserInput | DatabaseBackupUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: DatabaseBackupUpdateManyWithWhereWithoutUserInput | DatabaseBackupUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: DatabaseBackupScalarWhereInput | DatabaseBackupScalarWhereInput[]
  }

  export type BackupDestinationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput> | BackupDestinationCreateWithoutUserInput[] | BackupDestinationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: BackupDestinationCreateOrConnectWithoutUserInput | BackupDestinationCreateOrConnectWithoutUserInput[]
    upsert?: BackupDestinationUpsertWithWhereUniqueWithoutUserInput | BackupDestinationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: BackupDestinationCreateManyUserInputEnvelope
    set?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    disconnect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    delete?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    connect?: BackupDestinationWhereUniqueInput | BackupDestinationWhereUniqueInput[]
    update?: BackupDestinationUpdateWithWhereUniqueWithoutUserInput | BackupDestinationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: BackupDestinationUpdateManyWithWhereWithoutUserInput | BackupDestinationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: BackupDestinationScalarWhereInput | BackupDestinationScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutUserInput | NotificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutUserInput | NotificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutUserInput | NotificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type CloudFolderUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput> | CloudFolderCreateWithoutUserInput[] | CloudFolderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutUserInput | CloudFolderCreateOrConnectWithoutUserInput[]
    upsert?: CloudFolderUpsertWithWhereUniqueWithoutUserInput | CloudFolderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CloudFolderCreateManyUserInputEnvelope
    set?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    disconnect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    delete?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    update?: CloudFolderUpdateWithWhereUniqueWithoutUserInput | CloudFolderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CloudFolderUpdateManyWithWhereWithoutUserInput | CloudFolderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
  }

  export type CloudFileUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput> | CloudFileCreateWithoutUserInput[] | CloudFileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutUserInput | CloudFileCreateOrConnectWithoutUserInput[]
    upsert?: CloudFileUpsertWithWhereUniqueWithoutUserInput | CloudFileUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CloudFileCreateManyUserInputEnvelope
    set?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    disconnect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    delete?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    update?: CloudFileUpdateWithWhereUniqueWithoutUserInput | CloudFileUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CloudFileUpdateManyWithWhereWithoutUserInput | CloudFileUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
  }

  export type CommunicationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput> | CommunicationCreateWithoutUserInput[] | CommunicationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutUserInput | CommunicationCreateOrConnectWithoutUserInput[]
    upsert?: CommunicationUpsertWithWhereUniqueWithoutUserInput | CommunicationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: CommunicationCreateManyUserInputEnvelope
    set?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    disconnect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    delete?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    update?: CommunicationUpdateWithWhereUniqueWithoutUserInput | CommunicationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: CommunicationUpdateManyWithWhereWithoutUserInput | CommunicationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
  }

  export type TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: TwilioSettingsCreateOrConnectWithoutUserInput
    upsert?: TwilioSettingsUpsertWithoutUserInput
    disconnect?: TwilioSettingsWhereInput | boolean
    delete?: TwilioSettingsWhereInput | boolean
    connect?: TwilioSettingsWhereUniqueInput
    update?: XOR<XOR<TwilioSettingsUpdateToOneWithWhereWithoutUserInput, TwilioSettingsUpdateWithoutUserInput>, TwilioSettingsUncheckedUpdateWithoutUserInput>
  }

  export type AiSettingsUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AiSettingsCreateOrConnectWithoutUserInput
    upsert?: AiSettingsUpsertWithoutUserInput
    disconnect?: AiSettingsWhereInput | boolean
    delete?: AiSettingsWhereInput | boolean
    connect?: AiSettingsWhereUniqueInput
    update?: XOR<XOR<AiSettingsUpdateToOneWithWhereWithoutUserInput, AiSettingsUpdateWithoutUserInput>, AiSettingsUncheckedUpdateWithoutUserInput>
  }

  export type OfficeHoursUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeHoursCreateOrConnectWithoutUserInput
    upsert?: OfficeHoursUpsertWithoutUserInput
    disconnect?: OfficeHoursWhereInput | boolean
    delete?: OfficeHoursWhereInput | boolean
    connect?: OfficeHoursWhereUniqueInput
    update?: XOR<XOR<OfficeHoursUpdateToOneWithWhereWithoutUserInput, OfficeHoursUpdateWithoutUserInput>, OfficeHoursUncheckedUpdateWithoutUserInput>
  }

  export type OfficeContactUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
    connectOrCreate?: OfficeContactCreateOrConnectWithoutUserInput
    upsert?: OfficeContactUpsertWithoutUserInput
    disconnect?: OfficeContactWhereInput | boolean
    delete?: OfficeContactWhereInput | boolean
    connect?: OfficeContactWhereUniqueInput
    update?: XOR<XOR<OfficeContactUpdateToOneWithWhereWithoutUserInput, OfficeContactUpdateWithoutUserInput>, OfficeContactUncheckedUpdateWithoutUserInput>
  }

  export type ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProcedureTimeslotCreateOrConnectWithoutUserInput
    upsert?: ProcedureTimeslotUpsertWithoutUserInput
    disconnect?: ProcedureTimeslotWhereInput | boolean
    delete?: ProcedureTimeslotWhereInput | boolean
    connect?: ProcedureTimeslotWhereUniqueInput
    update?: XOR<XOR<ProcedureTimeslotUpdateToOneWithWhereWithoutUserInput, ProcedureTimeslotUpdateWithoutUserInput>, ProcedureTimeslotUncheckedUpdateWithoutUserInput>
  }

  export type InsuranceContactUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput> | InsuranceContactCreateWithoutUserInput[] | InsuranceContactUncheckedCreateWithoutUserInput[]
    connectOrCreate?: InsuranceContactCreateOrConnectWithoutUserInput | InsuranceContactCreateOrConnectWithoutUserInput[]
    upsert?: InsuranceContactUpsertWithWhereUniqueWithoutUserInput | InsuranceContactUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: InsuranceContactCreateManyUserInputEnvelope
    set?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    disconnect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    delete?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    connect?: InsuranceContactWhereUniqueInput | InsuranceContactWhereUniqueInput[]
    update?: InsuranceContactUpdateWithWhereUniqueWithoutUserInput | InsuranceContactUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: InsuranceContactUpdateManyWithWhereWithoutUserInput | InsuranceContactUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: InsuranceContactScalarWhereInput | InsuranceContactScalarWhereInput[]
  }

  export type PatientConversationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput> | PatientConversationCreateWithoutUserInput[] | PatientConversationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PatientConversationCreateOrConnectWithoutUserInput | PatientConversationCreateOrConnectWithoutUserInput[]
    upsert?: PatientConversationUpsertWithWhereUniqueWithoutUserInput | PatientConversationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PatientConversationCreateManyUserInputEnvelope
    set?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    disconnect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    delete?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    connect?: PatientConversationWhereUniqueInput | PatientConversationWhereUniqueInput[]
    update?: PatientConversationUpdateWithWhereUniqueWithoutUserInput | PatientConversationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PatientConversationUpdateManyWithWhereWithoutUserInput | PatientConversationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PatientConversationScalarWhereInput | PatientConversationScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutPatientsInput = {
    create?: XOR<UserCreateWithoutPatientsInput, UserUncheckedCreateWithoutPatientsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPatientsInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentCreateNestedManyWithoutPatientInput = {
    create?: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput> | AppointmentCreateWithoutPatientInput[] | AppointmentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPatientInput | AppointmentCreateOrConnectWithoutPatientInput[]
    createMany?: AppointmentCreateManyPatientInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AppointmentProcedureCreateNestedManyWithoutPatientInput = {
    create?: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput> | AppointmentProcedureCreateWithoutPatientInput[] | AppointmentProcedureUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutPatientInput | AppointmentProcedureCreateOrConnectWithoutPatientInput[]
    createMany?: AppointmentProcedureCreateManyPatientInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type ClaimCreateNestedManyWithoutPatientInput = {
    create?: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput> | ClaimCreateWithoutPatientInput[] | ClaimUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutPatientInput | ClaimCreateOrConnectWithoutPatientInput[]
    createMany?: ClaimCreateManyPatientInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type PdfGroupCreateNestedManyWithoutPatientInput = {
    create?: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput> | PdfGroupCreateWithoutPatientInput[] | PdfGroupUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPatientInput | PdfGroupCreateOrConnectWithoutPatientInput[]
    createMany?: PdfGroupCreateManyPatientInputEnvelope
    connect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
  }

  export type PaymentCreateNestedManyWithoutPatientInput = {
    create?: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput> | PaymentCreateWithoutPatientInput[] | PaymentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPatientInput | PaymentCreateOrConnectWithoutPatientInput[]
    createMany?: PaymentCreateManyPatientInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type CommunicationCreateNestedManyWithoutPatientInput = {
    create?: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput> | CommunicationCreateWithoutPatientInput[] | CommunicationUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutPatientInput | CommunicationCreateOrConnectWithoutPatientInput[]
    createMany?: CommunicationCreateManyPatientInputEnvelope
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
  }

  export type PatientDocumentCreateNestedManyWithoutPatientInput = {
    create?: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput> | PatientDocumentCreateWithoutPatientInput[] | PatientDocumentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PatientDocumentCreateOrConnectWithoutPatientInput | PatientDocumentCreateOrConnectWithoutPatientInput[]
    createMany?: PatientDocumentCreateManyPatientInputEnvelope
    connect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
  }

  export type PatientConversationCreateNestedOneWithoutPatientInput = {
    create?: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
    connectOrCreate?: PatientConversationCreateOrConnectWithoutPatientInput
    connect?: PatientConversationWhereUniqueInput
  }

  export type AppointmentUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput> | AppointmentCreateWithoutPatientInput[] | AppointmentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPatientInput | AppointmentCreateOrConnectWithoutPatientInput[]
    createMany?: AppointmentCreateManyPatientInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput> | AppointmentProcedureCreateWithoutPatientInput[] | AppointmentProcedureUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutPatientInput | AppointmentProcedureCreateOrConnectWithoutPatientInput[]
    createMany?: AppointmentProcedureCreateManyPatientInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type ClaimUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput> | ClaimCreateWithoutPatientInput[] | ClaimUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutPatientInput | ClaimCreateOrConnectWithoutPatientInput[]
    createMany?: ClaimCreateManyPatientInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type PdfGroupUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput> | PdfGroupCreateWithoutPatientInput[] | PdfGroupUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPatientInput | PdfGroupCreateOrConnectWithoutPatientInput[]
    createMany?: PdfGroupCreateManyPatientInputEnvelope
    connect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput> | PaymentCreateWithoutPatientInput[] | PaymentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPatientInput | PaymentCreateOrConnectWithoutPatientInput[]
    createMany?: PaymentCreateManyPatientInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type CommunicationUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput> | CommunicationCreateWithoutPatientInput[] | CommunicationUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutPatientInput | CommunicationCreateOrConnectWithoutPatientInput[]
    createMany?: CommunicationCreateManyPatientInputEnvelope
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
  }

  export type PatientDocumentUncheckedCreateNestedManyWithoutPatientInput = {
    create?: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput> | PatientDocumentCreateWithoutPatientInput[] | PatientDocumentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PatientDocumentCreateOrConnectWithoutPatientInput | PatientDocumentCreateOrConnectWithoutPatientInput[]
    createMany?: PatientDocumentCreateManyPatientInputEnvelope
    connect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
  }

  export type PatientConversationUncheckedCreateNestedOneWithoutPatientInput = {
    create?: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
    connectOrCreate?: PatientConversationCreateOrConnectWithoutPatientInput
    connect?: PatientConversationWhereUniqueInput
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type EnumPatientStatusFieldUpdateOperationsInput = {
    set?: $Enums.PatientStatus
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type UserUpdateOneRequiredWithoutPatientsNestedInput = {
    create?: XOR<UserCreateWithoutPatientsInput, UserUncheckedCreateWithoutPatientsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPatientsInput
    upsert?: UserUpsertWithoutPatientsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPatientsInput, UserUpdateWithoutPatientsInput>, UserUncheckedUpdateWithoutPatientsInput>
  }

  export type AppointmentUpdateManyWithoutPatientNestedInput = {
    create?: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput> | AppointmentCreateWithoutPatientInput[] | AppointmentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPatientInput | AppointmentCreateOrConnectWithoutPatientInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutPatientInput | AppointmentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: AppointmentCreateManyPatientInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutPatientInput | AppointmentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutPatientInput | AppointmentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AppointmentProcedureUpdateManyWithoutPatientNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput> | AppointmentProcedureCreateWithoutPatientInput[] | AppointmentProcedureUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutPatientInput | AppointmentProcedureCreateOrConnectWithoutPatientInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutPatientInput | AppointmentProcedureUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: AppointmentProcedureCreateManyPatientInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutPatientInput | AppointmentProcedureUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutPatientInput | AppointmentProcedureUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type ClaimUpdateManyWithoutPatientNestedInput = {
    create?: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput> | ClaimCreateWithoutPatientInput[] | ClaimUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutPatientInput | ClaimCreateOrConnectWithoutPatientInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutPatientInput | ClaimUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: ClaimCreateManyPatientInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutPatientInput | ClaimUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutPatientInput | ClaimUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type PdfGroupUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput> | PdfGroupCreateWithoutPatientInput[] | PdfGroupUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPatientInput | PdfGroupCreateOrConnectWithoutPatientInput[]
    upsert?: PdfGroupUpsertWithWhereUniqueWithoutPatientInput | PdfGroupUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PdfGroupCreateManyPatientInputEnvelope
    set?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    disconnect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    delete?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    connect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    update?: PdfGroupUpdateWithWhereUniqueWithoutPatientInput | PdfGroupUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PdfGroupUpdateManyWithWhereWithoutPatientInput | PdfGroupUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PdfGroupScalarWhereInput | PdfGroupScalarWhereInput[]
  }

  export type PaymentUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput> | PaymentCreateWithoutPatientInput[] | PaymentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPatientInput | PaymentCreateOrConnectWithoutPatientInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutPatientInput | PaymentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PaymentCreateManyPatientInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutPatientInput | PaymentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutPatientInput | PaymentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type CommunicationUpdateManyWithoutPatientNestedInput = {
    create?: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput> | CommunicationCreateWithoutPatientInput[] | CommunicationUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutPatientInput | CommunicationCreateOrConnectWithoutPatientInput[]
    upsert?: CommunicationUpsertWithWhereUniqueWithoutPatientInput | CommunicationUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: CommunicationCreateManyPatientInputEnvelope
    set?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    disconnect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    delete?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    update?: CommunicationUpdateWithWhereUniqueWithoutPatientInput | CommunicationUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: CommunicationUpdateManyWithWhereWithoutPatientInput | CommunicationUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
  }

  export type PatientDocumentUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput> | PatientDocumentCreateWithoutPatientInput[] | PatientDocumentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PatientDocumentCreateOrConnectWithoutPatientInput | PatientDocumentCreateOrConnectWithoutPatientInput[]
    upsert?: PatientDocumentUpsertWithWhereUniqueWithoutPatientInput | PatientDocumentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PatientDocumentCreateManyPatientInputEnvelope
    set?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    disconnect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    delete?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    connect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    update?: PatientDocumentUpdateWithWhereUniqueWithoutPatientInput | PatientDocumentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PatientDocumentUpdateManyWithWhereWithoutPatientInput | PatientDocumentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PatientDocumentScalarWhereInput | PatientDocumentScalarWhereInput[]
  }

  export type PatientConversationUpdateOneWithoutPatientNestedInput = {
    create?: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
    connectOrCreate?: PatientConversationCreateOrConnectWithoutPatientInput
    upsert?: PatientConversationUpsertWithoutPatientInput
    disconnect?: PatientConversationWhereInput | boolean
    delete?: PatientConversationWhereInput | boolean
    connect?: PatientConversationWhereUniqueInput
    update?: XOR<XOR<PatientConversationUpdateToOneWithWhereWithoutPatientInput, PatientConversationUpdateWithoutPatientInput>, PatientConversationUncheckedUpdateWithoutPatientInput>
  }

  export type AppointmentUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput> | AppointmentCreateWithoutPatientInput[] | AppointmentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPatientInput | AppointmentCreateOrConnectWithoutPatientInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutPatientInput | AppointmentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: AppointmentCreateManyPatientInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutPatientInput | AppointmentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutPatientInput | AppointmentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput> | AppointmentProcedureCreateWithoutPatientInput[] | AppointmentProcedureUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutPatientInput | AppointmentProcedureCreateOrConnectWithoutPatientInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutPatientInput | AppointmentProcedureUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: AppointmentProcedureCreateManyPatientInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutPatientInput | AppointmentProcedureUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutPatientInput | AppointmentProcedureUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type ClaimUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput> | ClaimCreateWithoutPatientInput[] | ClaimUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutPatientInput | ClaimCreateOrConnectWithoutPatientInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutPatientInput | ClaimUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: ClaimCreateManyPatientInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutPatientInput | ClaimUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutPatientInput | ClaimUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type PdfGroupUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput> | PdfGroupCreateWithoutPatientInput[] | PdfGroupUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPatientInput | PdfGroupCreateOrConnectWithoutPatientInput[]
    upsert?: PdfGroupUpsertWithWhereUniqueWithoutPatientInput | PdfGroupUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PdfGroupCreateManyPatientInputEnvelope
    set?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    disconnect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    delete?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    connect?: PdfGroupWhereUniqueInput | PdfGroupWhereUniqueInput[]
    update?: PdfGroupUpdateWithWhereUniqueWithoutPatientInput | PdfGroupUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PdfGroupUpdateManyWithWhereWithoutPatientInput | PdfGroupUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PdfGroupScalarWhereInput | PdfGroupScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput> | PaymentCreateWithoutPatientInput[] | PaymentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPatientInput | PaymentCreateOrConnectWithoutPatientInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutPatientInput | PaymentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PaymentCreateManyPatientInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutPatientInput | PaymentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutPatientInput | PaymentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type CommunicationUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput> | CommunicationCreateWithoutPatientInput[] | CommunicationUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: CommunicationCreateOrConnectWithoutPatientInput | CommunicationCreateOrConnectWithoutPatientInput[]
    upsert?: CommunicationUpsertWithWhereUniqueWithoutPatientInput | CommunicationUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: CommunicationCreateManyPatientInputEnvelope
    set?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    disconnect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    delete?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    connect?: CommunicationWhereUniqueInput | CommunicationWhereUniqueInput[]
    update?: CommunicationUpdateWithWhereUniqueWithoutPatientInput | CommunicationUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: CommunicationUpdateManyWithWhereWithoutPatientInput | CommunicationUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
  }

  export type PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput = {
    create?: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput> | PatientDocumentCreateWithoutPatientInput[] | PatientDocumentUncheckedCreateWithoutPatientInput[]
    connectOrCreate?: PatientDocumentCreateOrConnectWithoutPatientInput | PatientDocumentCreateOrConnectWithoutPatientInput[]
    upsert?: PatientDocumentUpsertWithWhereUniqueWithoutPatientInput | PatientDocumentUpsertWithWhereUniqueWithoutPatientInput[]
    createMany?: PatientDocumentCreateManyPatientInputEnvelope
    set?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    disconnect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    delete?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    connect?: PatientDocumentWhereUniqueInput | PatientDocumentWhereUniqueInput[]
    update?: PatientDocumentUpdateWithWhereUniqueWithoutPatientInput | PatientDocumentUpdateWithWhereUniqueWithoutPatientInput[]
    updateMany?: PatientDocumentUpdateManyWithWhereWithoutPatientInput | PatientDocumentUpdateManyWithWhereWithoutPatientInput[]
    deleteMany?: PatientDocumentScalarWhereInput | PatientDocumentScalarWhereInput[]
  }

  export type PatientConversationUncheckedUpdateOneWithoutPatientNestedInput = {
    create?: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
    connectOrCreate?: PatientConversationCreateOrConnectWithoutPatientInput
    upsert?: PatientConversationUpsertWithoutPatientInput
    disconnect?: PatientConversationWhereInput | boolean
    delete?: PatientConversationWhereInput | boolean
    connect?: PatientConversationWhereUniqueInput
    update?: XOR<XOR<PatientConversationUpdateToOneWithWhereWithoutPatientInput, PatientConversationUpdateWithoutPatientInput>, PatientConversationUncheckedUpdateWithoutPatientInput>
  }

  export type PatientCreateNestedOneWithoutAppointmentsInput = {
    create?: XOR<PatientCreateWithoutAppointmentsInput, PatientUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutAppointmentsInput
    connect?: PatientWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutAppointmentsInput = {
    create?: XOR<UserCreateWithoutAppointmentsInput, UserUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentsInput
    connect?: UserWhereUniqueInput
  }

  export type StaffCreateNestedOneWithoutAppointmentsInput = {
    create?: XOR<StaffCreateWithoutAppointmentsInput, StaffUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: StaffCreateOrConnectWithoutAppointmentsInput
    connect?: StaffWhereUniqueInput
  }

  export type AppointmentProcedureCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput> | AppointmentProcedureCreateWithoutAppointmentInput[] | AppointmentProcedureUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutAppointmentInput | AppointmentProcedureCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentProcedureCreateManyAppointmentInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type ClaimCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput> | ClaimCreateWithoutAppointmentInput[] | ClaimUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutAppointmentInput | ClaimCreateOrConnectWithoutAppointmentInput[]
    createMany?: ClaimCreateManyAppointmentInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type AppointmentFileCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput> | AppointmentFileCreateWithoutAppointmentInput[] | AppointmentFileUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentFileCreateOrConnectWithoutAppointmentInput | AppointmentFileCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentFileCreateManyAppointmentInputEnvelope
    connect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
  }

  export type AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput> | AppointmentProcedureCreateWithoutAppointmentInput[] | AppointmentProcedureUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutAppointmentInput | AppointmentProcedureCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentProcedureCreateManyAppointmentInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type ClaimUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput> | ClaimCreateWithoutAppointmentInput[] | ClaimUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutAppointmentInput | ClaimCreateOrConnectWithoutAppointmentInput[]
    createMany?: ClaimCreateManyAppointmentInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput> | AppointmentFileCreateWithoutAppointmentInput[] | AppointmentFileUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentFileCreateOrConnectWithoutAppointmentInput | AppointmentFileCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentFileCreateManyAppointmentInputEnvelope
    connect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
  }

  export type PatientUpdateOneRequiredWithoutAppointmentsNestedInput = {
    create?: XOR<PatientCreateWithoutAppointmentsInput, PatientUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutAppointmentsInput
    upsert?: PatientUpsertWithoutAppointmentsInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutAppointmentsInput, PatientUpdateWithoutAppointmentsInput>, PatientUncheckedUpdateWithoutAppointmentsInput>
  }

  export type UserUpdateOneRequiredWithoutAppointmentsNestedInput = {
    create?: XOR<UserCreateWithoutAppointmentsInput, UserUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentsInput
    upsert?: UserUpsertWithoutAppointmentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAppointmentsInput, UserUpdateWithoutAppointmentsInput>, UserUncheckedUpdateWithoutAppointmentsInput>
  }

  export type StaffUpdateOneWithoutAppointmentsNestedInput = {
    create?: XOR<StaffCreateWithoutAppointmentsInput, StaffUncheckedCreateWithoutAppointmentsInput>
    connectOrCreate?: StaffCreateOrConnectWithoutAppointmentsInput
    upsert?: StaffUpsertWithoutAppointmentsInput
    disconnect?: StaffWhereInput | boolean
    delete?: StaffWhereInput | boolean
    connect?: StaffWhereUniqueInput
    update?: XOR<XOR<StaffUpdateToOneWithWhereWithoutAppointmentsInput, StaffUpdateWithoutAppointmentsInput>, StaffUncheckedUpdateWithoutAppointmentsInput>
  }

  export type AppointmentProcedureUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput> | AppointmentProcedureCreateWithoutAppointmentInput[] | AppointmentProcedureUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutAppointmentInput | AppointmentProcedureCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentProcedureUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentProcedureCreateManyAppointmentInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentProcedureUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutAppointmentInput | AppointmentProcedureUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type ClaimUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput> | ClaimCreateWithoutAppointmentInput[] | ClaimUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutAppointmentInput | ClaimCreateOrConnectWithoutAppointmentInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutAppointmentInput | ClaimUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: ClaimCreateManyAppointmentInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutAppointmentInput | ClaimUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutAppointmentInput | ClaimUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type AppointmentFileUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput> | AppointmentFileCreateWithoutAppointmentInput[] | AppointmentFileUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentFileCreateOrConnectWithoutAppointmentInput | AppointmentFileCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentFileUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentFileUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentFileCreateManyAppointmentInputEnvelope
    set?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    disconnect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    delete?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    connect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    update?: AppointmentFileUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentFileUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentFileUpdateManyWithWhereWithoutAppointmentInput | AppointmentFileUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentFileScalarWhereInput | AppointmentFileScalarWhereInput[]
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput> | AppointmentProcedureCreateWithoutAppointmentInput[] | AppointmentProcedureUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutAppointmentInput | AppointmentProcedureCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentProcedureUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentProcedureCreateManyAppointmentInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentProcedureUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutAppointmentInput | AppointmentProcedureUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type ClaimUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput> | ClaimCreateWithoutAppointmentInput[] | ClaimUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutAppointmentInput | ClaimCreateOrConnectWithoutAppointmentInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutAppointmentInput | ClaimUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: ClaimCreateManyAppointmentInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutAppointmentInput | ClaimUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutAppointmentInput | ClaimUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput> | AppointmentFileCreateWithoutAppointmentInput[] | AppointmentFileUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentFileCreateOrConnectWithoutAppointmentInput | AppointmentFileCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentFileUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentFileUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentFileCreateManyAppointmentInputEnvelope
    set?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    disconnect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    delete?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    connect?: AppointmentFileWhereUniqueInput | AppointmentFileWhereUniqueInput[]
    update?: AppointmentFileUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentFileUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentFileUpdateManyWithWhereWithoutAppointmentInput | AppointmentFileUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentFileScalarWhereInput | AppointmentFileScalarWhereInput[]
  }

  export type AppointmentCreateNestedOneWithoutFilesInput = {
    create?: XOR<AppointmentCreateWithoutFilesInput, AppointmentUncheckedCreateWithoutFilesInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutFilesInput
    connect?: AppointmentWhereUniqueInput
  }

  export type AppointmentUpdateOneRequiredWithoutFilesNestedInput = {
    create?: XOR<AppointmentCreateWithoutFilesInput, AppointmentUncheckedCreateWithoutFilesInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutFilesInput
    upsert?: AppointmentUpsertWithoutFilesInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutFilesInput, AppointmentUpdateWithoutFilesInput>, AppointmentUncheckedUpdateWithoutFilesInput>
  }

  export type UserCreateNestedOneWithoutStaffInput = {
    create?: XOR<UserCreateWithoutStaffInput, UserUncheckedCreateWithoutStaffInput>
    connectOrCreate?: UserCreateOrConnectWithoutStaffInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentCreateNestedManyWithoutStaffInput = {
    create?: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput> | AppointmentCreateWithoutStaffInput[] | AppointmentUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutStaffInput | AppointmentCreateOrConnectWithoutStaffInput[]
    createMany?: AppointmentCreateManyStaffInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type ClaimCreateNestedManyWithoutStaffInput = {
    create?: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput> | ClaimCreateWithoutStaffInput[] | ClaimUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutStaffInput | ClaimCreateOrConnectWithoutStaffInput[]
    createMany?: ClaimCreateManyStaffInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type AppointmentUncheckedCreateNestedManyWithoutStaffInput = {
    create?: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput> | AppointmentCreateWithoutStaffInput[] | AppointmentUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutStaffInput | AppointmentCreateOrConnectWithoutStaffInput[]
    createMany?: AppointmentCreateManyStaffInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type ClaimUncheckedCreateNestedManyWithoutStaffInput = {
    create?: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput> | ClaimCreateWithoutStaffInput[] | ClaimUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutStaffInput | ClaimCreateOrConnectWithoutStaffInput[]
    createMany?: ClaimCreateManyStaffInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type UserUpdateOneWithoutStaffNestedInput = {
    create?: XOR<UserCreateWithoutStaffInput, UserUncheckedCreateWithoutStaffInput>
    connectOrCreate?: UserCreateOrConnectWithoutStaffInput
    upsert?: UserUpsertWithoutStaffInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutStaffInput, UserUpdateWithoutStaffInput>, UserUncheckedUpdateWithoutStaffInput>
  }

  export type AppointmentUpdateManyWithoutStaffNestedInput = {
    create?: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput> | AppointmentCreateWithoutStaffInput[] | AppointmentUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutStaffInput | AppointmentCreateOrConnectWithoutStaffInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutStaffInput | AppointmentUpsertWithWhereUniqueWithoutStaffInput[]
    createMany?: AppointmentCreateManyStaffInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutStaffInput | AppointmentUpdateWithWhereUniqueWithoutStaffInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutStaffInput | AppointmentUpdateManyWithWhereWithoutStaffInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type ClaimUpdateManyWithoutStaffNestedInput = {
    create?: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput> | ClaimCreateWithoutStaffInput[] | ClaimUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutStaffInput | ClaimCreateOrConnectWithoutStaffInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutStaffInput | ClaimUpsertWithWhereUniqueWithoutStaffInput[]
    createMany?: ClaimCreateManyStaffInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutStaffInput | ClaimUpdateWithWhereUniqueWithoutStaffInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutStaffInput | ClaimUpdateManyWithWhereWithoutStaffInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type AppointmentUncheckedUpdateManyWithoutStaffNestedInput = {
    create?: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput> | AppointmentCreateWithoutStaffInput[] | AppointmentUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutStaffInput | AppointmentCreateOrConnectWithoutStaffInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutStaffInput | AppointmentUpsertWithWhereUniqueWithoutStaffInput[]
    createMany?: AppointmentCreateManyStaffInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutStaffInput | AppointmentUpdateWithWhereUniqueWithoutStaffInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutStaffInput | AppointmentUpdateManyWithWhereWithoutStaffInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type ClaimUncheckedUpdateManyWithoutStaffNestedInput = {
    create?: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput> | ClaimCreateWithoutStaffInput[] | ClaimUncheckedCreateWithoutStaffInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutStaffInput | ClaimCreateOrConnectWithoutStaffInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutStaffInput | ClaimUpsertWithWhereUniqueWithoutStaffInput[]
    createMany?: ClaimCreateManyStaffInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutStaffInput | ClaimUpdateWithWhereUniqueWithoutStaffInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutStaffInput | ClaimUpdateManyWithWhereWithoutStaffInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutNpiProvidersInput = {
    create?: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
    connectOrCreate?: UserCreateOrConnectWithoutNpiProvidersInput
    connect?: UserWhereUniqueInput
  }

  export type ClaimCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput> | ClaimCreateWithoutNpiProviderInput[] | ClaimUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutNpiProviderInput | ClaimCreateOrConnectWithoutNpiProviderInput[]
    createMany?: ClaimCreateManyNpiProviderInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type PaymentCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput> | PaymentCreateWithoutNpiProviderInput[] | PaymentUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutNpiProviderInput | PaymentCreateOrConnectWithoutNpiProviderInput[]
    createMany?: PaymentCreateManyNpiProviderInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type CommissionBatchCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput> | CommissionBatchCreateWithoutNpiProviderInput[] | CommissionBatchUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutNpiProviderInput | CommissionBatchCreateOrConnectWithoutNpiProviderInput[]
    createMany?: CommissionBatchCreateManyNpiProviderInputEnvelope
    connect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
  }

  export type AppointmentProcedureCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput> | AppointmentProcedureCreateWithoutNpiProviderInput[] | AppointmentProcedureUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutNpiProviderInput | AppointmentProcedureCreateOrConnectWithoutNpiProviderInput[]
    createMany?: AppointmentProcedureCreateManyNpiProviderInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type ClaimUncheckedCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput> | ClaimCreateWithoutNpiProviderInput[] | ClaimUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutNpiProviderInput | ClaimCreateOrConnectWithoutNpiProviderInput[]
    createMany?: ClaimCreateManyNpiProviderInputEnvelope
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput> | PaymentCreateWithoutNpiProviderInput[] | PaymentUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutNpiProviderInput | PaymentCreateOrConnectWithoutNpiProviderInput[]
    createMany?: PaymentCreateManyNpiProviderInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput> | CommissionBatchCreateWithoutNpiProviderInput[] | CommissionBatchUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutNpiProviderInput | CommissionBatchCreateOrConnectWithoutNpiProviderInput[]
    createMany?: CommissionBatchCreateManyNpiProviderInputEnvelope
    connect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
  }

  export type AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput = {
    create?: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput> | AppointmentProcedureCreateWithoutNpiProviderInput[] | AppointmentProcedureUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutNpiProviderInput | AppointmentProcedureCreateOrConnectWithoutNpiProviderInput[]
    createMany?: AppointmentProcedureCreateManyNpiProviderInputEnvelope
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutNpiProvidersNestedInput = {
    create?: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
    connectOrCreate?: UserCreateOrConnectWithoutNpiProvidersInput
    upsert?: UserUpsertWithoutNpiProvidersInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutNpiProvidersInput, UserUpdateWithoutNpiProvidersInput>, UserUncheckedUpdateWithoutNpiProvidersInput>
  }

  export type ClaimUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput> | ClaimCreateWithoutNpiProviderInput[] | ClaimUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutNpiProviderInput | ClaimCreateOrConnectWithoutNpiProviderInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutNpiProviderInput | ClaimUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: ClaimCreateManyNpiProviderInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutNpiProviderInput | ClaimUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutNpiProviderInput | ClaimUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type PaymentUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput> | PaymentCreateWithoutNpiProviderInput[] | PaymentUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutNpiProviderInput | PaymentCreateOrConnectWithoutNpiProviderInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutNpiProviderInput | PaymentUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: PaymentCreateManyNpiProviderInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutNpiProviderInput | PaymentUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutNpiProviderInput | PaymentUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type CommissionBatchUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput> | CommissionBatchCreateWithoutNpiProviderInput[] | CommissionBatchUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutNpiProviderInput | CommissionBatchCreateOrConnectWithoutNpiProviderInput[]
    upsert?: CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput | CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: CommissionBatchCreateManyNpiProviderInputEnvelope
    set?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    disconnect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    delete?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    connect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    update?: CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput | CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput | CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: CommissionBatchScalarWhereInput | CommissionBatchScalarWhereInput[]
  }

  export type AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput> | AppointmentProcedureCreateWithoutNpiProviderInput[] | AppointmentProcedureUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutNpiProviderInput | AppointmentProcedureCreateOrConnectWithoutNpiProviderInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutNpiProviderInput | AppointmentProcedureUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: AppointmentProcedureCreateManyNpiProviderInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutNpiProviderInput | AppointmentProcedureUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutNpiProviderInput | AppointmentProcedureUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput> | ClaimCreateWithoutNpiProviderInput[] | ClaimUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: ClaimCreateOrConnectWithoutNpiProviderInput | ClaimCreateOrConnectWithoutNpiProviderInput[]
    upsert?: ClaimUpsertWithWhereUniqueWithoutNpiProviderInput | ClaimUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: ClaimCreateManyNpiProviderInputEnvelope
    set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
    update?: ClaimUpdateWithWhereUniqueWithoutNpiProviderInput | ClaimUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: ClaimUpdateManyWithWhereWithoutNpiProviderInput | ClaimUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput> | PaymentCreateWithoutNpiProviderInput[] | PaymentUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutNpiProviderInput | PaymentCreateOrConnectWithoutNpiProviderInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutNpiProviderInput | PaymentUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: PaymentCreateManyNpiProviderInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutNpiProviderInput | PaymentUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutNpiProviderInput | PaymentUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput> | CommissionBatchCreateWithoutNpiProviderInput[] | CommissionBatchUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutNpiProviderInput | CommissionBatchCreateOrConnectWithoutNpiProviderInput[]
    upsert?: CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput | CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: CommissionBatchCreateManyNpiProviderInputEnvelope
    set?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    disconnect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    delete?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    connect?: CommissionBatchWhereUniqueInput | CommissionBatchWhereUniqueInput[]
    update?: CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput | CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput | CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: CommissionBatchScalarWhereInput | CommissionBatchScalarWhereInput[]
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput = {
    create?: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput> | AppointmentProcedureCreateWithoutNpiProviderInput[] | AppointmentProcedureUncheckedCreateWithoutNpiProviderInput[]
    connectOrCreate?: AppointmentProcedureCreateOrConnectWithoutNpiProviderInput | AppointmentProcedureCreateOrConnectWithoutNpiProviderInput[]
    upsert?: AppointmentProcedureUpsertWithWhereUniqueWithoutNpiProviderInput | AppointmentProcedureUpsertWithWhereUniqueWithoutNpiProviderInput[]
    createMany?: AppointmentProcedureCreateManyNpiProviderInputEnvelope
    set?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    disconnect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    delete?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    connect?: AppointmentProcedureWhereUniqueInput | AppointmentProcedureWhereUniqueInput[]
    update?: AppointmentProcedureUpdateWithWhereUniqueWithoutNpiProviderInput | AppointmentProcedureUpdateWithWhereUniqueWithoutNpiProviderInput[]
    updateMany?: AppointmentProcedureUpdateManyWithWhereWithoutNpiProviderInput | AppointmentProcedureUpdateManyWithWhereWithoutNpiProviderInput[]
    deleteMany?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
  }

  export type AppointmentCreateNestedOneWithoutProceduresInput = {
    create?: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutProceduresInput
    connect?: AppointmentWhereUniqueInput
  }

  export type PatientCreateNestedOneWithoutProceduresInput = {
    create?: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: PatientCreateOrConnectWithoutProceduresInput
    connect?: PatientWhereUniqueInput
  }

  export type NpiProviderCreateNestedOneWithoutAppointmentProceduresInput = {
    create?: XOR<NpiProviderCreateWithoutAppointmentProceduresInput, NpiProviderUncheckedCreateWithoutAppointmentProceduresInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutAppointmentProceduresInput
    connect?: NpiProviderWhereUniqueInput
  }

  export type NullableDecimalFieldUpdateOperationsInput = {
    set?: Decimal | DecimalJsLike | number | string | null
    increment?: Decimal | DecimalJsLike | number | string
    decrement?: Decimal | DecimalJsLike | number | string
    multiply?: Decimal | DecimalJsLike | number | string
    divide?: Decimal | DecimalJsLike | number | string
  }

  export type EnumProcedureSourceFieldUpdateOperationsInput = {
    set?: $Enums.ProcedureSource
  }

  export type AppointmentUpdateOneRequiredWithoutProceduresNestedInput = {
    create?: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutProceduresInput
    upsert?: AppointmentUpsertWithoutProceduresInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutProceduresInput, AppointmentUpdateWithoutProceduresInput>, AppointmentUncheckedUpdateWithoutProceduresInput>
  }

  export type PatientUpdateOneRequiredWithoutProceduresNestedInput = {
    create?: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: PatientCreateOrConnectWithoutProceduresInput
    upsert?: PatientUpsertWithoutProceduresInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutProceduresInput, PatientUpdateWithoutProceduresInput>, PatientUncheckedUpdateWithoutProceduresInput>
  }

  export type NpiProviderUpdateOneWithoutAppointmentProceduresNestedInput = {
    create?: XOR<NpiProviderCreateWithoutAppointmentProceduresInput, NpiProviderUncheckedCreateWithoutAppointmentProceduresInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutAppointmentProceduresInput
    upsert?: NpiProviderUpsertWithoutAppointmentProceduresInput
    disconnect?: NpiProviderWhereInput | boolean
    delete?: NpiProviderWhereInput | boolean
    connect?: NpiProviderWhereUniqueInput
    update?: XOR<XOR<NpiProviderUpdateToOneWithWhereWithoutAppointmentProceduresInput, NpiProviderUpdateWithoutAppointmentProceduresInput>, NpiProviderUncheckedUpdateWithoutAppointmentProceduresInput>
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type PatientCreateNestedOneWithoutClaimsInput = {
    create?: XOR<PatientCreateWithoutClaimsInput, PatientUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutClaimsInput
    connect?: PatientWhereUniqueInput
  }

  export type AppointmentCreateNestedOneWithoutClaimsInput = {
    create?: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutClaimsInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutClaimsInput = {
    create?: XOR<UserCreateWithoutClaimsInput, UserUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: UserCreateOrConnectWithoutClaimsInput
    connect?: UserWhereUniqueInput
  }

  export type StaffCreateNestedOneWithoutClaimsInput = {
    create?: XOR<StaffCreateWithoutClaimsInput, StaffUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: StaffCreateOrConnectWithoutClaimsInput
    connect?: StaffWhereUniqueInput
  }

  export type NpiProviderCreateNestedOneWithoutClaimsInput = {
    create?: XOR<NpiProviderCreateWithoutClaimsInput, NpiProviderUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutClaimsInput
    connect?: NpiProviderWhereUniqueInput
  }

  export type ServiceLineCreateNestedManyWithoutClaimInput = {
    create?: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput> | ServiceLineCreateWithoutClaimInput[] | ServiceLineUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutClaimInput | ServiceLineCreateOrConnectWithoutClaimInput[]
    createMany?: ServiceLineCreateManyClaimInputEnvelope
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
  }

  export type ClaimFileCreateNestedManyWithoutClaimInput = {
    create?: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput> | ClaimFileCreateWithoutClaimInput[] | ClaimFileUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ClaimFileCreateOrConnectWithoutClaimInput | ClaimFileCreateOrConnectWithoutClaimInput[]
    createMany?: ClaimFileCreateManyClaimInputEnvelope
    connect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
  }

  export type PaymentCreateNestedOneWithoutClaimInput = {
    create?: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutClaimInput
    connect?: PaymentWhereUniqueInput
  }

  export type ServiceLineUncheckedCreateNestedManyWithoutClaimInput = {
    create?: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput> | ServiceLineCreateWithoutClaimInput[] | ServiceLineUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutClaimInput | ServiceLineCreateOrConnectWithoutClaimInput[]
    createMany?: ServiceLineCreateManyClaimInputEnvelope
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
  }

  export type ClaimFileUncheckedCreateNestedManyWithoutClaimInput = {
    create?: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput> | ClaimFileCreateWithoutClaimInput[] | ClaimFileUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ClaimFileCreateOrConnectWithoutClaimInput | ClaimFileCreateOrConnectWithoutClaimInput[]
    createMany?: ClaimFileCreateManyClaimInputEnvelope
    connect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedOneWithoutClaimInput = {
    create?: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutClaimInput
    connect?: PaymentWhereUniqueInput
  }

  export type EnumMissingTeethStatusFieldUpdateOperationsInput = {
    set?: $Enums.MissingTeethStatus
  }

  export type EnumClaimStatusFieldUpdateOperationsInput = {
    set?: $Enums.ClaimStatus
  }

  export type PatientUpdateOneRequiredWithoutClaimsNestedInput = {
    create?: XOR<PatientCreateWithoutClaimsInput, PatientUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutClaimsInput
    upsert?: PatientUpsertWithoutClaimsInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutClaimsInput, PatientUpdateWithoutClaimsInput>, PatientUncheckedUpdateWithoutClaimsInput>
  }

  export type AppointmentUpdateOneWithoutClaimsNestedInput = {
    create?: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutClaimsInput
    upsert?: AppointmentUpsertWithoutClaimsInput
    disconnect?: AppointmentWhereInput | boolean
    delete?: AppointmentWhereInput | boolean
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutClaimsInput, AppointmentUpdateWithoutClaimsInput>, AppointmentUncheckedUpdateWithoutClaimsInput>
  }

  export type UserUpdateOneWithoutClaimsNestedInput = {
    create?: XOR<UserCreateWithoutClaimsInput, UserUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: UserCreateOrConnectWithoutClaimsInput
    upsert?: UserUpsertWithoutClaimsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutClaimsInput, UserUpdateWithoutClaimsInput>, UserUncheckedUpdateWithoutClaimsInput>
  }

  export type StaffUpdateOneWithoutClaimsNestedInput = {
    create?: XOR<StaffCreateWithoutClaimsInput, StaffUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: StaffCreateOrConnectWithoutClaimsInput
    upsert?: StaffUpsertWithoutClaimsInput
    disconnect?: StaffWhereInput | boolean
    delete?: StaffWhereInput | boolean
    connect?: StaffWhereUniqueInput
    update?: XOR<XOR<StaffUpdateToOneWithWhereWithoutClaimsInput, StaffUpdateWithoutClaimsInput>, StaffUncheckedUpdateWithoutClaimsInput>
  }

  export type NpiProviderUpdateOneWithoutClaimsNestedInput = {
    create?: XOR<NpiProviderCreateWithoutClaimsInput, NpiProviderUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutClaimsInput
    upsert?: NpiProviderUpsertWithoutClaimsInput
    disconnect?: NpiProviderWhereInput | boolean
    delete?: NpiProviderWhereInput | boolean
    connect?: NpiProviderWhereUniqueInput
    update?: XOR<XOR<NpiProviderUpdateToOneWithWhereWithoutClaimsInput, NpiProviderUpdateWithoutClaimsInput>, NpiProviderUncheckedUpdateWithoutClaimsInput>
  }

  export type ServiceLineUpdateManyWithoutClaimNestedInput = {
    create?: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput> | ServiceLineCreateWithoutClaimInput[] | ServiceLineUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutClaimInput | ServiceLineCreateOrConnectWithoutClaimInput[]
    upsert?: ServiceLineUpsertWithWhereUniqueWithoutClaimInput | ServiceLineUpsertWithWhereUniqueWithoutClaimInput[]
    createMany?: ServiceLineCreateManyClaimInputEnvelope
    set?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    disconnect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    delete?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    update?: ServiceLineUpdateWithWhereUniqueWithoutClaimInput | ServiceLineUpdateWithWhereUniqueWithoutClaimInput[]
    updateMany?: ServiceLineUpdateManyWithWhereWithoutClaimInput | ServiceLineUpdateManyWithWhereWithoutClaimInput[]
    deleteMany?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
  }

  export type ClaimFileUpdateManyWithoutClaimNestedInput = {
    create?: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput> | ClaimFileCreateWithoutClaimInput[] | ClaimFileUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ClaimFileCreateOrConnectWithoutClaimInput | ClaimFileCreateOrConnectWithoutClaimInput[]
    upsert?: ClaimFileUpsertWithWhereUniqueWithoutClaimInput | ClaimFileUpsertWithWhereUniqueWithoutClaimInput[]
    createMany?: ClaimFileCreateManyClaimInputEnvelope
    set?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    disconnect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    delete?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    connect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    update?: ClaimFileUpdateWithWhereUniqueWithoutClaimInput | ClaimFileUpdateWithWhereUniqueWithoutClaimInput[]
    updateMany?: ClaimFileUpdateManyWithWhereWithoutClaimInput | ClaimFileUpdateManyWithWhereWithoutClaimInput[]
    deleteMany?: ClaimFileScalarWhereInput | ClaimFileScalarWhereInput[]
  }

  export type PaymentUpdateOneWithoutClaimNestedInput = {
    create?: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutClaimInput
    upsert?: PaymentUpsertWithoutClaimInput
    disconnect?: PaymentWhereInput | boolean
    delete?: PaymentWhereInput | boolean
    connect?: PaymentWhereUniqueInput
    update?: XOR<XOR<PaymentUpdateToOneWithWhereWithoutClaimInput, PaymentUpdateWithoutClaimInput>, PaymentUncheckedUpdateWithoutClaimInput>
  }

  export type ServiceLineUncheckedUpdateManyWithoutClaimNestedInput = {
    create?: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput> | ServiceLineCreateWithoutClaimInput[] | ServiceLineUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutClaimInput | ServiceLineCreateOrConnectWithoutClaimInput[]
    upsert?: ServiceLineUpsertWithWhereUniqueWithoutClaimInput | ServiceLineUpsertWithWhereUniqueWithoutClaimInput[]
    createMany?: ServiceLineCreateManyClaimInputEnvelope
    set?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    disconnect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    delete?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    update?: ServiceLineUpdateWithWhereUniqueWithoutClaimInput | ServiceLineUpdateWithWhereUniqueWithoutClaimInput[]
    updateMany?: ServiceLineUpdateManyWithWhereWithoutClaimInput | ServiceLineUpdateManyWithWhereWithoutClaimInput[]
    deleteMany?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
  }

  export type ClaimFileUncheckedUpdateManyWithoutClaimNestedInput = {
    create?: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput> | ClaimFileCreateWithoutClaimInput[] | ClaimFileUncheckedCreateWithoutClaimInput[]
    connectOrCreate?: ClaimFileCreateOrConnectWithoutClaimInput | ClaimFileCreateOrConnectWithoutClaimInput[]
    upsert?: ClaimFileUpsertWithWhereUniqueWithoutClaimInput | ClaimFileUpsertWithWhereUniqueWithoutClaimInput[]
    createMany?: ClaimFileCreateManyClaimInputEnvelope
    set?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    disconnect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    delete?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    connect?: ClaimFileWhereUniqueInput | ClaimFileWhereUniqueInput[]
    update?: ClaimFileUpdateWithWhereUniqueWithoutClaimInput | ClaimFileUpdateWithWhereUniqueWithoutClaimInput[]
    updateMany?: ClaimFileUpdateManyWithWhereWithoutClaimInput | ClaimFileUpdateManyWithWhereWithoutClaimInput[]
    deleteMany?: ClaimFileScalarWhereInput | ClaimFileScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateOneWithoutClaimNestedInput = {
    create?: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutClaimInput
    upsert?: PaymentUpsertWithoutClaimInput
    disconnect?: PaymentWhereInput | boolean
    delete?: PaymentWhereInput | boolean
    connect?: PaymentWhereUniqueInput
    update?: XOR<XOR<PaymentUpdateToOneWithWhereWithoutClaimInput, PaymentUpdateWithoutClaimInput>, PaymentUncheckedUpdateWithoutClaimInput>
  }

  export type ClaimCreateNestedOneWithoutServiceLinesInput = {
    create?: XOR<ClaimCreateWithoutServiceLinesInput, ClaimUncheckedCreateWithoutServiceLinesInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutServiceLinesInput
    connect?: ClaimWhereUniqueInput
  }

  export type PaymentCreateNestedOneWithoutServiceLinesInput = {
    create?: XOR<PaymentCreateWithoutServiceLinesInput, PaymentUncheckedCreateWithoutServiceLinesInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutServiceLinesInput
    connect?: PaymentWhereUniqueInput
  }

  export type ServiceLineTransactionCreateNestedManyWithoutServiceLineInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput> | ServiceLineTransactionCreateWithoutServiceLineInput[] | ServiceLineTransactionUncheckedCreateWithoutServiceLineInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutServiceLineInput | ServiceLineTransactionCreateOrConnectWithoutServiceLineInput[]
    createMany?: ServiceLineTransactionCreateManyServiceLineInputEnvelope
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
  }

  export type ServiceLineTransactionUncheckedCreateNestedManyWithoutServiceLineInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput> | ServiceLineTransactionCreateWithoutServiceLineInput[] | ServiceLineTransactionUncheckedCreateWithoutServiceLineInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutServiceLineInput | ServiceLineTransactionCreateOrConnectWithoutServiceLineInput[]
    createMany?: ServiceLineTransactionCreateManyServiceLineInputEnvelope
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
  }

  export type DecimalFieldUpdateOperationsInput = {
    set?: Decimal | DecimalJsLike | number | string
    increment?: Decimal | DecimalJsLike | number | string
    decrement?: Decimal | DecimalJsLike | number | string
    multiply?: Decimal | DecimalJsLike | number | string
    divide?: Decimal | DecimalJsLike | number | string
  }

  export type EnumServiceLineStatusFieldUpdateOperationsInput = {
    set?: $Enums.ServiceLineStatus
  }

  export type ClaimUpdateOneWithoutServiceLinesNestedInput = {
    create?: XOR<ClaimCreateWithoutServiceLinesInput, ClaimUncheckedCreateWithoutServiceLinesInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutServiceLinesInput
    upsert?: ClaimUpsertWithoutServiceLinesInput
    disconnect?: ClaimWhereInput | boolean
    delete?: ClaimWhereInput | boolean
    connect?: ClaimWhereUniqueInput
    update?: XOR<XOR<ClaimUpdateToOneWithWhereWithoutServiceLinesInput, ClaimUpdateWithoutServiceLinesInput>, ClaimUncheckedUpdateWithoutServiceLinesInput>
  }

  export type PaymentUpdateOneWithoutServiceLinesNestedInput = {
    create?: XOR<PaymentCreateWithoutServiceLinesInput, PaymentUncheckedCreateWithoutServiceLinesInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutServiceLinesInput
    upsert?: PaymentUpsertWithoutServiceLinesInput
    disconnect?: PaymentWhereInput | boolean
    delete?: PaymentWhereInput | boolean
    connect?: PaymentWhereUniqueInput
    update?: XOR<XOR<PaymentUpdateToOneWithWhereWithoutServiceLinesInput, PaymentUpdateWithoutServiceLinesInput>, PaymentUncheckedUpdateWithoutServiceLinesInput>
  }

  export type ServiceLineTransactionUpdateManyWithoutServiceLineNestedInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput> | ServiceLineTransactionCreateWithoutServiceLineInput[] | ServiceLineTransactionUncheckedCreateWithoutServiceLineInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutServiceLineInput | ServiceLineTransactionCreateOrConnectWithoutServiceLineInput[]
    upsert?: ServiceLineTransactionUpsertWithWhereUniqueWithoutServiceLineInput | ServiceLineTransactionUpsertWithWhereUniqueWithoutServiceLineInput[]
    createMany?: ServiceLineTransactionCreateManyServiceLineInputEnvelope
    set?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    disconnect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    delete?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    update?: ServiceLineTransactionUpdateWithWhereUniqueWithoutServiceLineInput | ServiceLineTransactionUpdateWithWhereUniqueWithoutServiceLineInput[]
    updateMany?: ServiceLineTransactionUpdateManyWithWhereWithoutServiceLineInput | ServiceLineTransactionUpdateManyWithWhereWithoutServiceLineInput[]
    deleteMany?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
  }

  export type ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineNestedInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput> | ServiceLineTransactionCreateWithoutServiceLineInput[] | ServiceLineTransactionUncheckedCreateWithoutServiceLineInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutServiceLineInput | ServiceLineTransactionCreateOrConnectWithoutServiceLineInput[]
    upsert?: ServiceLineTransactionUpsertWithWhereUniqueWithoutServiceLineInput | ServiceLineTransactionUpsertWithWhereUniqueWithoutServiceLineInput[]
    createMany?: ServiceLineTransactionCreateManyServiceLineInputEnvelope
    set?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    disconnect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    delete?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    update?: ServiceLineTransactionUpdateWithWhereUniqueWithoutServiceLineInput | ServiceLineTransactionUpdateWithWhereUniqueWithoutServiceLineInput[]
    updateMany?: ServiceLineTransactionUpdateManyWithWhereWithoutServiceLineInput | ServiceLineTransactionUpdateManyWithWhereWithoutServiceLineInput[]
    deleteMany?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
  }

  export type ClaimCreateNestedOneWithoutClaimFilesInput = {
    create?: XOR<ClaimCreateWithoutClaimFilesInput, ClaimUncheckedCreateWithoutClaimFilesInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutClaimFilesInput
    connect?: ClaimWhereUniqueInput
  }

  export type ClaimUpdateOneRequiredWithoutClaimFilesNestedInput = {
    create?: XOR<ClaimCreateWithoutClaimFilesInput, ClaimUncheckedCreateWithoutClaimFilesInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutClaimFilesInput
    upsert?: ClaimUpsertWithoutClaimFilesInput
    connect?: ClaimWhereUniqueInput
    update?: XOR<XOR<ClaimUpdateToOneWithWhereWithoutClaimFilesInput, ClaimUpdateWithoutClaimFilesInput>, ClaimUncheckedUpdateWithoutClaimFilesInput>
  }

  export type UserCreateNestedOneWithoutInsuranceCredentialsInput = {
    create?: XOR<UserCreateWithoutInsuranceCredentialsInput, UserUncheckedCreateWithoutInsuranceCredentialsInput>
    connectOrCreate?: UserCreateOrConnectWithoutInsuranceCredentialsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutInsuranceCredentialsNestedInput = {
    create?: XOR<UserCreateWithoutInsuranceCredentialsInput, UserUncheckedCreateWithoutInsuranceCredentialsInput>
    connectOrCreate?: UserCreateOrConnectWithoutInsuranceCredentialsInput
    upsert?: UserUpsertWithoutInsuranceCredentialsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutInsuranceCredentialsInput, UserUpdateWithoutInsuranceCredentialsInput>, UserUncheckedUpdateWithoutInsuranceCredentialsInput>
  }

  export type UserCreateNestedOneWithoutShoppingVendorsInput = {
    create?: XOR<UserCreateWithoutShoppingVendorsInput, UserUncheckedCreateWithoutShoppingVendorsInput>
    connectOrCreate?: UserCreateOrConnectWithoutShoppingVendorsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutShoppingVendorsNestedInput = {
    create?: XOR<UserCreateWithoutShoppingVendorsInput, UserUncheckedCreateWithoutShoppingVendorsInput>
    connectOrCreate?: UserCreateOrConnectWithoutShoppingVendorsInput
    upsert?: UserUpsertWithoutShoppingVendorsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutShoppingVendorsInput, UserUpdateWithoutShoppingVendorsInput>, UserUncheckedUpdateWithoutShoppingVendorsInput>
  }

  export type PatientCreateNestedOneWithoutGroupsInput = {
    create?: XOR<PatientCreateWithoutGroupsInput, PatientUncheckedCreateWithoutGroupsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutGroupsInput
    connect?: PatientWhereUniqueInput
  }

  export type PdfFileCreateNestedManyWithoutGroupInput = {
    create?: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput> | PdfFileCreateWithoutGroupInput[] | PdfFileUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: PdfFileCreateOrConnectWithoutGroupInput | PdfFileCreateOrConnectWithoutGroupInput[]
    createMany?: PdfFileCreateManyGroupInputEnvelope
    connect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
  }

  export type PdfFileUncheckedCreateNestedManyWithoutGroupInput = {
    create?: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput> | PdfFileCreateWithoutGroupInput[] | PdfFileUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: PdfFileCreateOrConnectWithoutGroupInput | PdfFileCreateOrConnectWithoutGroupInput[]
    createMany?: PdfFileCreateManyGroupInputEnvelope
    connect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
  }

  export type EnumPdfTitleKeyFieldUpdateOperationsInput = {
    set?: $Enums.PdfTitleKey
  }

  export type PatientUpdateOneRequiredWithoutGroupsNestedInput = {
    create?: XOR<PatientCreateWithoutGroupsInput, PatientUncheckedCreateWithoutGroupsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutGroupsInput
    upsert?: PatientUpsertWithoutGroupsInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutGroupsInput, PatientUpdateWithoutGroupsInput>, PatientUncheckedUpdateWithoutGroupsInput>
  }

  export type PdfFileUpdateManyWithoutGroupNestedInput = {
    create?: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput> | PdfFileCreateWithoutGroupInput[] | PdfFileUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: PdfFileCreateOrConnectWithoutGroupInput | PdfFileCreateOrConnectWithoutGroupInput[]
    upsert?: PdfFileUpsertWithWhereUniqueWithoutGroupInput | PdfFileUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: PdfFileCreateManyGroupInputEnvelope
    set?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    disconnect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    delete?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    connect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    update?: PdfFileUpdateWithWhereUniqueWithoutGroupInput | PdfFileUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: PdfFileUpdateManyWithWhereWithoutGroupInput | PdfFileUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: PdfFileScalarWhereInput | PdfFileScalarWhereInput[]
  }

  export type PdfFileUncheckedUpdateManyWithoutGroupNestedInput = {
    create?: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput> | PdfFileCreateWithoutGroupInput[] | PdfFileUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: PdfFileCreateOrConnectWithoutGroupInput | PdfFileCreateOrConnectWithoutGroupInput[]
    upsert?: PdfFileUpsertWithWhereUniqueWithoutGroupInput | PdfFileUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: PdfFileCreateManyGroupInputEnvelope
    set?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    disconnect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    delete?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    connect?: PdfFileWhereUniqueInput | PdfFileWhereUniqueInput[]
    update?: PdfFileUpdateWithWhereUniqueWithoutGroupInput | PdfFileUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: PdfFileUpdateManyWithWhereWithoutGroupInput | PdfFileUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: PdfFileScalarWhereInput | PdfFileScalarWhereInput[]
  }

  export type PdfGroupCreateNestedOneWithoutPdfsInput = {
    create?: XOR<PdfGroupCreateWithoutPdfsInput, PdfGroupUncheckedCreateWithoutPdfsInput>
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPdfsInput
    connect?: PdfGroupWhereUniqueInput
  }

  export type BytesFieldUpdateOperationsInput = {
    set?: Bytes
  }

  export type PdfGroupUpdateOneRequiredWithoutPdfsNestedInput = {
    create?: XOR<PdfGroupCreateWithoutPdfsInput, PdfGroupUncheckedCreateWithoutPdfsInput>
    connectOrCreate?: PdfGroupCreateOrConnectWithoutPdfsInput
    upsert?: PdfGroupUpsertWithoutPdfsInput
    connect?: PdfGroupWhereUniqueInput
    update?: XOR<XOR<PdfGroupUpdateToOneWithWhereWithoutPdfsInput, PdfGroupUpdateWithoutPdfsInput>, PdfGroupUncheckedUpdateWithoutPdfsInput>
  }

  export type ClaimCreateNestedOneWithoutPaymentInput = {
    create?: XOR<ClaimCreateWithoutPaymentInput, ClaimUncheckedCreateWithoutPaymentInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutPaymentInput
    connect?: ClaimWhereUniqueInput
  }

  export type PatientCreateNestedOneWithoutPaymentInput = {
    create?: XOR<PatientCreateWithoutPaymentInput, PatientUncheckedCreateWithoutPaymentInput>
    connectOrCreate?: PatientCreateOrConnectWithoutPaymentInput
    connect?: PatientWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutUpdatedPaymentsInput = {
    create?: XOR<UserCreateWithoutUpdatedPaymentsInput, UserUncheckedCreateWithoutUpdatedPaymentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutUpdatedPaymentsInput
    connect?: UserWhereUniqueInput
  }

  export type NpiProviderCreateNestedOneWithoutPaymentsInput = {
    create?: XOR<NpiProviderCreateWithoutPaymentsInput, NpiProviderUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutPaymentsInput
    connect?: NpiProviderWhereUniqueInput
  }

  export type ServiceLineTransactionCreateNestedManyWithoutPaymentInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput> | ServiceLineTransactionCreateWithoutPaymentInput[] | ServiceLineTransactionUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutPaymentInput | ServiceLineTransactionCreateOrConnectWithoutPaymentInput[]
    createMany?: ServiceLineTransactionCreateManyPaymentInputEnvelope
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
  }

  export type ServiceLineCreateNestedManyWithoutPaymentInput = {
    create?: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput> | ServiceLineCreateWithoutPaymentInput[] | ServiceLineUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutPaymentInput | ServiceLineCreateOrConnectWithoutPaymentInput[]
    createMany?: ServiceLineCreateManyPaymentInputEnvelope
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
  }

  export type CommissionBatchItemCreateNestedManyWithoutPaymentInput = {
    create?: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput> | CommissionBatchItemCreateWithoutPaymentInput[] | CommissionBatchItemUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutPaymentInput | CommissionBatchItemCreateOrConnectWithoutPaymentInput[]
    createMany?: CommissionBatchItemCreateManyPaymentInputEnvelope
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
  }

  export type ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput> | ServiceLineTransactionCreateWithoutPaymentInput[] | ServiceLineTransactionUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutPaymentInput | ServiceLineTransactionCreateOrConnectWithoutPaymentInput[]
    createMany?: ServiceLineTransactionCreateManyPaymentInputEnvelope
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
  }

  export type ServiceLineUncheckedCreateNestedManyWithoutPaymentInput = {
    create?: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput> | ServiceLineCreateWithoutPaymentInput[] | ServiceLineUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutPaymentInput | ServiceLineCreateOrConnectWithoutPaymentInput[]
    createMany?: ServiceLineCreateManyPaymentInputEnvelope
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
  }

  export type CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput = {
    create?: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput> | CommissionBatchItemCreateWithoutPaymentInput[] | CommissionBatchItemUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutPaymentInput | CommissionBatchItemCreateOrConnectWithoutPaymentInput[]
    createMany?: CommissionBatchItemCreateManyPaymentInputEnvelope
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
  }

  export type EnumPaymentStatusFieldUpdateOperationsInput = {
    set?: $Enums.PaymentStatus
  }

  export type ClaimUpdateOneWithoutPaymentNestedInput = {
    create?: XOR<ClaimCreateWithoutPaymentInput, ClaimUncheckedCreateWithoutPaymentInput>
    connectOrCreate?: ClaimCreateOrConnectWithoutPaymentInput
    upsert?: ClaimUpsertWithoutPaymentInput
    disconnect?: ClaimWhereInput | boolean
    delete?: ClaimWhereInput | boolean
    connect?: ClaimWhereUniqueInput
    update?: XOR<XOR<ClaimUpdateToOneWithWhereWithoutPaymentInput, ClaimUpdateWithoutPaymentInput>, ClaimUncheckedUpdateWithoutPaymentInput>
  }

  export type PatientUpdateOneRequiredWithoutPaymentNestedInput = {
    create?: XOR<PatientCreateWithoutPaymentInput, PatientUncheckedCreateWithoutPaymentInput>
    connectOrCreate?: PatientCreateOrConnectWithoutPaymentInput
    upsert?: PatientUpsertWithoutPaymentInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutPaymentInput, PatientUpdateWithoutPaymentInput>, PatientUncheckedUpdateWithoutPaymentInput>
  }

  export type UserUpdateOneWithoutUpdatedPaymentsNestedInput = {
    create?: XOR<UserCreateWithoutUpdatedPaymentsInput, UserUncheckedCreateWithoutUpdatedPaymentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutUpdatedPaymentsInput
    upsert?: UserUpsertWithoutUpdatedPaymentsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutUpdatedPaymentsInput, UserUpdateWithoutUpdatedPaymentsInput>, UserUncheckedUpdateWithoutUpdatedPaymentsInput>
  }

  export type NpiProviderUpdateOneWithoutPaymentsNestedInput = {
    create?: XOR<NpiProviderCreateWithoutPaymentsInput, NpiProviderUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutPaymentsInput
    upsert?: NpiProviderUpsertWithoutPaymentsInput
    disconnect?: NpiProviderWhereInput | boolean
    delete?: NpiProviderWhereInput | boolean
    connect?: NpiProviderWhereUniqueInput
    update?: XOR<XOR<NpiProviderUpdateToOneWithWhereWithoutPaymentsInput, NpiProviderUpdateWithoutPaymentsInput>, NpiProviderUncheckedUpdateWithoutPaymentsInput>
  }

  export type ServiceLineTransactionUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput> | ServiceLineTransactionCreateWithoutPaymentInput[] | ServiceLineTransactionUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutPaymentInput | ServiceLineTransactionCreateOrConnectWithoutPaymentInput[]
    upsert?: ServiceLineTransactionUpsertWithWhereUniqueWithoutPaymentInput | ServiceLineTransactionUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: ServiceLineTransactionCreateManyPaymentInputEnvelope
    set?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    disconnect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    delete?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    update?: ServiceLineTransactionUpdateWithWhereUniqueWithoutPaymentInput | ServiceLineTransactionUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: ServiceLineTransactionUpdateManyWithWhereWithoutPaymentInput | ServiceLineTransactionUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
  }

  export type ServiceLineUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput> | ServiceLineCreateWithoutPaymentInput[] | ServiceLineUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutPaymentInput | ServiceLineCreateOrConnectWithoutPaymentInput[]
    upsert?: ServiceLineUpsertWithWhereUniqueWithoutPaymentInput | ServiceLineUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: ServiceLineCreateManyPaymentInputEnvelope
    set?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    disconnect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    delete?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    update?: ServiceLineUpdateWithWhereUniqueWithoutPaymentInput | ServiceLineUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: ServiceLineUpdateManyWithWhereWithoutPaymentInput | ServiceLineUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
  }

  export type CommissionBatchItemUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput> | CommissionBatchItemCreateWithoutPaymentInput[] | CommissionBatchItemUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutPaymentInput | CommissionBatchItemCreateOrConnectWithoutPaymentInput[]
    upsert?: CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput | CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: CommissionBatchItemCreateManyPaymentInputEnvelope
    set?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    disconnect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    delete?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    update?: CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput | CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput | CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
  }

  export type ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput> | ServiceLineTransactionCreateWithoutPaymentInput[] | ServiceLineTransactionUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineTransactionCreateOrConnectWithoutPaymentInput | ServiceLineTransactionCreateOrConnectWithoutPaymentInput[]
    upsert?: ServiceLineTransactionUpsertWithWhereUniqueWithoutPaymentInput | ServiceLineTransactionUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: ServiceLineTransactionCreateManyPaymentInputEnvelope
    set?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    disconnect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    delete?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    connect?: ServiceLineTransactionWhereUniqueInput | ServiceLineTransactionWhereUniqueInput[]
    update?: ServiceLineTransactionUpdateWithWhereUniqueWithoutPaymentInput | ServiceLineTransactionUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: ServiceLineTransactionUpdateManyWithWhereWithoutPaymentInput | ServiceLineTransactionUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
  }

  export type ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput> | ServiceLineCreateWithoutPaymentInput[] | ServiceLineUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: ServiceLineCreateOrConnectWithoutPaymentInput | ServiceLineCreateOrConnectWithoutPaymentInput[]
    upsert?: ServiceLineUpsertWithWhereUniqueWithoutPaymentInput | ServiceLineUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: ServiceLineCreateManyPaymentInputEnvelope
    set?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    disconnect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    delete?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    connect?: ServiceLineWhereUniqueInput | ServiceLineWhereUniqueInput[]
    update?: ServiceLineUpdateWithWhereUniqueWithoutPaymentInput | ServiceLineUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: ServiceLineUpdateManyWithWhereWithoutPaymentInput | ServiceLineUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
  }

  export type CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput = {
    create?: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput> | CommissionBatchItemCreateWithoutPaymentInput[] | CommissionBatchItemUncheckedCreateWithoutPaymentInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutPaymentInput | CommissionBatchItemCreateOrConnectWithoutPaymentInput[]
    upsert?: CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput | CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput[]
    createMany?: CommissionBatchItemCreateManyPaymentInputEnvelope
    set?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    disconnect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    delete?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    update?: CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput | CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput[]
    updateMany?: CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput | CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput[]
    deleteMany?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
  }

  export type PaymentCreateNestedOneWithoutServiceLineTransactionsInput = {
    create?: XOR<PaymentCreateWithoutServiceLineTransactionsInput, PaymentUncheckedCreateWithoutServiceLineTransactionsInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutServiceLineTransactionsInput
    connect?: PaymentWhereUniqueInput
  }

  export type ServiceLineCreateNestedOneWithoutServiceLineTransactionsInput = {
    create?: XOR<ServiceLineCreateWithoutServiceLineTransactionsInput, ServiceLineUncheckedCreateWithoutServiceLineTransactionsInput>
    connectOrCreate?: ServiceLineCreateOrConnectWithoutServiceLineTransactionsInput
    connect?: ServiceLineWhereUniqueInput
  }

  export type EnumPaymentMethodFieldUpdateOperationsInput = {
    set?: $Enums.PaymentMethod
  }

  export type PaymentUpdateOneRequiredWithoutServiceLineTransactionsNestedInput = {
    create?: XOR<PaymentCreateWithoutServiceLineTransactionsInput, PaymentUncheckedCreateWithoutServiceLineTransactionsInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutServiceLineTransactionsInput
    upsert?: PaymentUpsertWithoutServiceLineTransactionsInput
    connect?: PaymentWhereUniqueInput
    update?: XOR<XOR<PaymentUpdateToOneWithWhereWithoutServiceLineTransactionsInput, PaymentUpdateWithoutServiceLineTransactionsInput>, PaymentUncheckedUpdateWithoutServiceLineTransactionsInput>
  }

  export type ServiceLineUpdateOneRequiredWithoutServiceLineTransactionsNestedInput = {
    create?: XOR<ServiceLineCreateWithoutServiceLineTransactionsInput, ServiceLineUncheckedCreateWithoutServiceLineTransactionsInput>
    connectOrCreate?: ServiceLineCreateOrConnectWithoutServiceLineTransactionsInput
    upsert?: ServiceLineUpsertWithoutServiceLineTransactionsInput
    connect?: ServiceLineWhereUniqueInput
    update?: XOR<XOR<ServiceLineUpdateToOneWithWhereWithoutServiceLineTransactionsInput, ServiceLineUpdateWithoutServiceLineTransactionsInput>, ServiceLineUncheckedUpdateWithoutServiceLineTransactionsInput>
  }

  export type UserCreateNestedOneWithoutBackupsInput = {
    create?: XOR<UserCreateWithoutBackupsInput, UserUncheckedCreateWithoutBackupsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBackupsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutBackupsNestedInput = {
    create?: XOR<UserCreateWithoutBackupsInput, UserUncheckedCreateWithoutBackupsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBackupsInput
    upsert?: UserUpsertWithoutBackupsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutBackupsInput, UserUpdateWithoutBackupsInput>, UserUncheckedUpdateWithoutBackupsInput>
  }

  export type UserCreateNestedOneWithoutBackupDestinationsInput = {
    create?: XOR<UserCreateWithoutBackupDestinationsInput, UserUncheckedCreateWithoutBackupDestinationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBackupDestinationsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutBackupDestinationsNestedInput = {
    create?: XOR<UserCreateWithoutBackupDestinationsInput, UserUncheckedCreateWithoutBackupDestinationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBackupDestinationsInput
    upsert?: UserUpsertWithoutBackupDestinationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutBackupDestinationsInput, UserUpdateWithoutBackupDestinationsInput>, UserUncheckedUpdateWithoutBackupDestinationsInput>
  }

  export type UserCreateNestedOneWithoutNotificationsInput = {
    create?: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutNotificationsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumNotificationTypesFieldUpdateOperationsInput = {
    set?: $Enums.NotificationTypes
  }

  export type UserUpdateOneRequiredWithoutNotificationsNestedInput = {
    create?: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutNotificationsInput
    upsert?: UserUpsertWithoutNotificationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutNotificationsInput, UserUpdateWithoutNotificationsInput>, UserUncheckedUpdateWithoutNotificationsInput>
  }

  export type CloudFolderCreateNestedOneWithoutChildrenInput = {
    create?: XOR<CloudFolderCreateWithoutChildrenInput, CloudFolderUncheckedCreateWithoutChildrenInput>
    connectOrCreate?: CloudFolderCreateOrConnectWithoutChildrenInput
    connect?: CloudFolderWhereUniqueInput
  }

  export type CloudFolderCreateNestedManyWithoutParentInput = {
    create?: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput> | CloudFolderCreateWithoutParentInput[] | CloudFolderUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutParentInput | CloudFolderCreateOrConnectWithoutParentInput[]
    createMany?: CloudFolderCreateManyParentInputEnvelope
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutCloudFoldersInput = {
    create?: XOR<UserCreateWithoutCloudFoldersInput, UserUncheckedCreateWithoutCloudFoldersInput>
    connectOrCreate?: UserCreateOrConnectWithoutCloudFoldersInput
    connect?: UserWhereUniqueInput
  }

  export type CloudFileCreateNestedManyWithoutFolderInput = {
    create?: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput> | CloudFileCreateWithoutFolderInput[] | CloudFileUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutFolderInput | CloudFileCreateOrConnectWithoutFolderInput[]
    createMany?: CloudFileCreateManyFolderInputEnvelope
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
  }

  export type CloudFolderUncheckedCreateNestedManyWithoutParentInput = {
    create?: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput> | CloudFolderCreateWithoutParentInput[] | CloudFolderUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutParentInput | CloudFolderCreateOrConnectWithoutParentInput[]
    createMany?: CloudFolderCreateManyParentInputEnvelope
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
  }

  export type CloudFileUncheckedCreateNestedManyWithoutFolderInput = {
    create?: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput> | CloudFileCreateWithoutFolderInput[] | CloudFileUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutFolderInput | CloudFileCreateOrConnectWithoutFolderInput[]
    createMany?: CloudFileCreateManyFolderInputEnvelope
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
  }

  export type CloudFolderUpdateOneWithoutChildrenNestedInput = {
    create?: XOR<CloudFolderCreateWithoutChildrenInput, CloudFolderUncheckedCreateWithoutChildrenInput>
    connectOrCreate?: CloudFolderCreateOrConnectWithoutChildrenInput
    upsert?: CloudFolderUpsertWithoutChildrenInput
    disconnect?: CloudFolderWhereInput | boolean
    delete?: CloudFolderWhereInput | boolean
    connect?: CloudFolderWhereUniqueInput
    update?: XOR<XOR<CloudFolderUpdateToOneWithWhereWithoutChildrenInput, CloudFolderUpdateWithoutChildrenInput>, CloudFolderUncheckedUpdateWithoutChildrenInput>
  }

  export type CloudFolderUpdateManyWithoutParentNestedInput = {
    create?: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput> | CloudFolderCreateWithoutParentInput[] | CloudFolderUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutParentInput | CloudFolderCreateOrConnectWithoutParentInput[]
    upsert?: CloudFolderUpsertWithWhereUniqueWithoutParentInput | CloudFolderUpsertWithWhereUniqueWithoutParentInput[]
    createMany?: CloudFolderCreateManyParentInputEnvelope
    set?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    disconnect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    delete?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    update?: CloudFolderUpdateWithWhereUniqueWithoutParentInput | CloudFolderUpdateWithWhereUniqueWithoutParentInput[]
    updateMany?: CloudFolderUpdateManyWithWhereWithoutParentInput | CloudFolderUpdateManyWithWhereWithoutParentInput[]
    deleteMany?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
  }

  export type UserUpdateOneRequiredWithoutCloudFoldersNestedInput = {
    create?: XOR<UserCreateWithoutCloudFoldersInput, UserUncheckedCreateWithoutCloudFoldersInput>
    connectOrCreate?: UserCreateOrConnectWithoutCloudFoldersInput
    upsert?: UserUpsertWithoutCloudFoldersInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutCloudFoldersInput, UserUpdateWithoutCloudFoldersInput>, UserUncheckedUpdateWithoutCloudFoldersInput>
  }

  export type CloudFileUpdateManyWithoutFolderNestedInput = {
    create?: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput> | CloudFileCreateWithoutFolderInput[] | CloudFileUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutFolderInput | CloudFileCreateOrConnectWithoutFolderInput[]
    upsert?: CloudFileUpsertWithWhereUniqueWithoutFolderInput | CloudFileUpsertWithWhereUniqueWithoutFolderInput[]
    createMany?: CloudFileCreateManyFolderInputEnvelope
    set?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    disconnect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    delete?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    update?: CloudFileUpdateWithWhereUniqueWithoutFolderInput | CloudFileUpdateWithWhereUniqueWithoutFolderInput[]
    updateMany?: CloudFileUpdateManyWithWhereWithoutFolderInput | CloudFileUpdateManyWithWhereWithoutFolderInput[]
    deleteMany?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
  }

  export type CloudFolderUncheckedUpdateManyWithoutParentNestedInput = {
    create?: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput> | CloudFolderCreateWithoutParentInput[] | CloudFolderUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CloudFolderCreateOrConnectWithoutParentInput | CloudFolderCreateOrConnectWithoutParentInput[]
    upsert?: CloudFolderUpsertWithWhereUniqueWithoutParentInput | CloudFolderUpsertWithWhereUniqueWithoutParentInput[]
    createMany?: CloudFolderCreateManyParentInputEnvelope
    set?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    disconnect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    delete?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    connect?: CloudFolderWhereUniqueInput | CloudFolderWhereUniqueInput[]
    update?: CloudFolderUpdateWithWhereUniqueWithoutParentInput | CloudFolderUpdateWithWhereUniqueWithoutParentInput[]
    updateMany?: CloudFolderUpdateManyWithWhereWithoutParentInput | CloudFolderUpdateManyWithWhereWithoutParentInput[]
    deleteMany?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
  }

  export type CloudFileUncheckedUpdateManyWithoutFolderNestedInput = {
    create?: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput> | CloudFileCreateWithoutFolderInput[] | CloudFileUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: CloudFileCreateOrConnectWithoutFolderInput | CloudFileCreateOrConnectWithoutFolderInput[]
    upsert?: CloudFileUpsertWithWhereUniqueWithoutFolderInput | CloudFileUpsertWithWhereUniqueWithoutFolderInput[]
    createMany?: CloudFileCreateManyFolderInputEnvelope
    set?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    disconnect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    delete?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    connect?: CloudFileWhereUniqueInput | CloudFileWhereUniqueInput[]
    update?: CloudFileUpdateWithWhereUniqueWithoutFolderInput | CloudFileUpdateWithWhereUniqueWithoutFolderInput[]
    updateMany?: CloudFileUpdateManyWithWhereWithoutFolderInput | CloudFileUpdateManyWithWhereWithoutFolderInput[]
    deleteMany?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutCloudFilesInput = {
    create?: XOR<UserCreateWithoutCloudFilesInput, UserUncheckedCreateWithoutCloudFilesInput>
    connectOrCreate?: UserCreateOrConnectWithoutCloudFilesInput
    connect?: UserWhereUniqueInput
  }

  export type CloudFolderCreateNestedOneWithoutFilesInput = {
    create?: XOR<CloudFolderCreateWithoutFilesInput, CloudFolderUncheckedCreateWithoutFilesInput>
    connectOrCreate?: CloudFolderCreateOrConnectWithoutFilesInput
    connect?: CloudFolderWhereUniqueInput
  }

  export type CloudFileChunkCreateNestedManyWithoutFileInput = {
    create?: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput> | CloudFileChunkCreateWithoutFileInput[] | CloudFileChunkUncheckedCreateWithoutFileInput[]
    connectOrCreate?: CloudFileChunkCreateOrConnectWithoutFileInput | CloudFileChunkCreateOrConnectWithoutFileInput[]
    createMany?: CloudFileChunkCreateManyFileInputEnvelope
    connect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
  }

  export type CloudFileChunkUncheckedCreateNestedManyWithoutFileInput = {
    create?: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput> | CloudFileChunkCreateWithoutFileInput[] | CloudFileChunkUncheckedCreateWithoutFileInput[]
    connectOrCreate?: CloudFileChunkCreateOrConnectWithoutFileInput | CloudFileChunkCreateOrConnectWithoutFileInput[]
    createMany?: CloudFileChunkCreateManyFileInputEnvelope
    connect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
  }

  export type BigIntFieldUpdateOperationsInput = {
    set?: bigint | number
    increment?: bigint | number
    decrement?: bigint | number
    multiply?: bigint | number
    divide?: bigint | number
  }

  export type UserUpdateOneRequiredWithoutCloudFilesNestedInput = {
    create?: XOR<UserCreateWithoutCloudFilesInput, UserUncheckedCreateWithoutCloudFilesInput>
    connectOrCreate?: UserCreateOrConnectWithoutCloudFilesInput
    upsert?: UserUpsertWithoutCloudFilesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutCloudFilesInput, UserUpdateWithoutCloudFilesInput>, UserUncheckedUpdateWithoutCloudFilesInput>
  }

  export type CloudFolderUpdateOneWithoutFilesNestedInput = {
    create?: XOR<CloudFolderCreateWithoutFilesInput, CloudFolderUncheckedCreateWithoutFilesInput>
    connectOrCreate?: CloudFolderCreateOrConnectWithoutFilesInput
    upsert?: CloudFolderUpsertWithoutFilesInput
    disconnect?: CloudFolderWhereInput | boolean
    delete?: CloudFolderWhereInput | boolean
    connect?: CloudFolderWhereUniqueInput
    update?: XOR<XOR<CloudFolderUpdateToOneWithWhereWithoutFilesInput, CloudFolderUpdateWithoutFilesInput>, CloudFolderUncheckedUpdateWithoutFilesInput>
  }

  export type CloudFileChunkUpdateManyWithoutFileNestedInput = {
    create?: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput> | CloudFileChunkCreateWithoutFileInput[] | CloudFileChunkUncheckedCreateWithoutFileInput[]
    connectOrCreate?: CloudFileChunkCreateOrConnectWithoutFileInput | CloudFileChunkCreateOrConnectWithoutFileInput[]
    upsert?: CloudFileChunkUpsertWithWhereUniqueWithoutFileInput | CloudFileChunkUpsertWithWhereUniqueWithoutFileInput[]
    createMany?: CloudFileChunkCreateManyFileInputEnvelope
    set?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    disconnect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    delete?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    connect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    update?: CloudFileChunkUpdateWithWhereUniqueWithoutFileInput | CloudFileChunkUpdateWithWhereUniqueWithoutFileInput[]
    updateMany?: CloudFileChunkUpdateManyWithWhereWithoutFileInput | CloudFileChunkUpdateManyWithWhereWithoutFileInput[]
    deleteMany?: CloudFileChunkScalarWhereInput | CloudFileChunkScalarWhereInput[]
  }

  export type CloudFileChunkUncheckedUpdateManyWithoutFileNestedInput = {
    create?: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput> | CloudFileChunkCreateWithoutFileInput[] | CloudFileChunkUncheckedCreateWithoutFileInput[]
    connectOrCreate?: CloudFileChunkCreateOrConnectWithoutFileInput | CloudFileChunkCreateOrConnectWithoutFileInput[]
    upsert?: CloudFileChunkUpsertWithWhereUniqueWithoutFileInput | CloudFileChunkUpsertWithWhereUniqueWithoutFileInput[]
    createMany?: CloudFileChunkCreateManyFileInputEnvelope
    set?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    disconnect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    delete?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    connect?: CloudFileChunkWhereUniqueInput | CloudFileChunkWhereUniqueInput[]
    update?: CloudFileChunkUpdateWithWhereUniqueWithoutFileInput | CloudFileChunkUpdateWithWhereUniqueWithoutFileInput[]
    updateMany?: CloudFileChunkUpdateManyWithWhereWithoutFileInput | CloudFileChunkUpdateManyWithWhereWithoutFileInput[]
    deleteMany?: CloudFileChunkScalarWhereInput | CloudFileChunkScalarWhereInput[]
  }

  export type CloudFileCreateNestedOneWithoutChunksInput = {
    create?: XOR<CloudFileCreateWithoutChunksInput, CloudFileUncheckedCreateWithoutChunksInput>
    connectOrCreate?: CloudFileCreateOrConnectWithoutChunksInput
    connect?: CloudFileWhereUniqueInput
  }

  export type CloudFileUpdateOneRequiredWithoutChunksNestedInput = {
    create?: XOR<CloudFileCreateWithoutChunksInput, CloudFileUncheckedCreateWithoutChunksInput>
    connectOrCreate?: CloudFileCreateOrConnectWithoutChunksInput
    upsert?: CloudFileUpsertWithoutChunksInput
    connect?: CloudFileWhereUniqueInput
    update?: XOR<XOR<CloudFileUpdateToOneWithWhereWithoutChunksInput, CloudFileUpdateWithoutChunksInput>, CloudFileUncheckedUpdateWithoutChunksInput>
  }

  export type PatientCreateNestedOneWithoutCommunicationsInput = {
    create?: XOR<PatientCreateWithoutCommunicationsInput, PatientUncheckedCreateWithoutCommunicationsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutCommunicationsInput
    connect?: PatientWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutCommunicationsInput = {
    create?: XOR<UserCreateWithoutCommunicationsInput, UserUncheckedCreateWithoutCommunicationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutCommunicationsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumCommunicationChannelFieldUpdateOperationsInput = {
    set?: $Enums.CommunicationChannel
  }

  export type EnumCommunicationDirectionFieldUpdateOperationsInput = {
    set?: $Enums.CommunicationDirection
  }

  export type EnumCommunicationStatusFieldUpdateOperationsInput = {
    set?: $Enums.CommunicationStatus
  }

  export type PatientUpdateOneRequiredWithoutCommunicationsNestedInput = {
    create?: XOR<PatientCreateWithoutCommunicationsInput, PatientUncheckedCreateWithoutCommunicationsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutCommunicationsInput
    upsert?: PatientUpsertWithoutCommunicationsInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutCommunicationsInput, PatientUpdateWithoutCommunicationsInput>, PatientUncheckedUpdateWithoutCommunicationsInput>
  }

  export type UserUpdateOneWithoutCommunicationsNestedInput = {
    create?: XOR<UserCreateWithoutCommunicationsInput, UserUncheckedCreateWithoutCommunicationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutCommunicationsInput
    upsert?: UserUpsertWithoutCommunicationsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutCommunicationsInput, UserUpdateWithoutCommunicationsInput>, UserUncheckedUpdateWithoutCommunicationsInput>
  }

  export type PatientCreateNestedOneWithoutDocumentsInput = {
    create?: XOR<PatientCreateWithoutDocumentsInput, PatientUncheckedCreateWithoutDocumentsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutDocumentsInput
    connect?: PatientWhereUniqueInput
  }

  export type PatientUpdateOneRequiredWithoutDocumentsNestedInput = {
    create?: XOR<PatientCreateWithoutDocumentsInput, PatientUncheckedCreateWithoutDocumentsInput>
    connectOrCreate?: PatientCreateOrConnectWithoutDocumentsInput
    upsert?: PatientUpsertWithoutDocumentsInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutDocumentsInput, PatientUpdateWithoutDocumentsInput>, PatientUncheckedUpdateWithoutDocumentsInput>
  }

  export type UserCreateNestedOneWithoutTwilioSettingsInput = {
    create?: XOR<UserCreateWithoutTwilioSettingsInput, UserUncheckedCreateWithoutTwilioSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTwilioSettingsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutTwilioSettingsNestedInput = {
    create?: XOR<UserCreateWithoutTwilioSettingsInput, UserUncheckedCreateWithoutTwilioSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTwilioSettingsInput
    upsert?: UserUpsertWithoutTwilioSettingsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutTwilioSettingsInput, UserUpdateWithoutTwilioSettingsInput>, UserUncheckedUpdateWithoutTwilioSettingsInput>
  }

  export type UserCreateNestedOneWithoutAiSettingsInput = {
    create?: XOR<UserCreateWithoutAiSettingsInput, UserUncheckedCreateWithoutAiSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAiSettingsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutAiSettingsNestedInput = {
    create?: XOR<UserCreateWithoutAiSettingsInput, UserUncheckedCreateWithoutAiSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAiSettingsInput
    upsert?: UserUpsertWithoutAiSettingsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAiSettingsInput, UserUpdateWithoutAiSettingsInput>, UserUncheckedUpdateWithoutAiSettingsInput>
  }

  export type UserCreateNestedOneWithoutOfficeHoursInput = {
    create?: XOR<UserCreateWithoutOfficeHoursInput, UserUncheckedCreateWithoutOfficeHoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutOfficeHoursInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutOfficeHoursNestedInput = {
    create?: XOR<UserCreateWithoutOfficeHoursInput, UserUncheckedCreateWithoutOfficeHoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutOfficeHoursInput
    upsert?: UserUpsertWithoutOfficeHoursInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOfficeHoursInput, UserUpdateWithoutOfficeHoursInput>, UserUncheckedUpdateWithoutOfficeHoursInput>
  }

  export type UserCreateNestedOneWithoutOfficeContactInput = {
    create?: XOR<UserCreateWithoutOfficeContactInput, UserUncheckedCreateWithoutOfficeContactInput>
    connectOrCreate?: UserCreateOrConnectWithoutOfficeContactInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutOfficeContactNestedInput = {
    create?: XOR<UserCreateWithoutOfficeContactInput, UserUncheckedCreateWithoutOfficeContactInput>
    connectOrCreate?: UserCreateOrConnectWithoutOfficeContactInput
    upsert?: UserUpsertWithoutOfficeContactInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOfficeContactInput, UserUpdateWithoutOfficeContactInput>, UserUncheckedUpdateWithoutOfficeContactInput>
  }

  export type UserCreateNestedOneWithoutInsuranceContactsInput = {
    create?: XOR<UserCreateWithoutInsuranceContactsInput, UserUncheckedCreateWithoutInsuranceContactsInput>
    connectOrCreate?: UserCreateOrConnectWithoutInsuranceContactsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutInsuranceContactsNestedInput = {
    create?: XOR<UserCreateWithoutInsuranceContactsInput, UserUncheckedCreateWithoutInsuranceContactsInput>
    connectOrCreate?: UserCreateOrConnectWithoutInsuranceContactsInput
    upsert?: UserUpsertWithoutInsuranceContactsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutInsuranceContactsInput, UserUpdateWithoutInsuranceContactsInput>, UserUncheckedUpdateWithoutInsuranceContactsInput>
  }

  export type UserCreateNestedOneWithoutProcedureTimeslotInput = {
    create?: XOR<UserCreateWithoutProcedureTimeslotInput, UserUncheckedCreateWithoutProcedureTimeslotInput>
    connectOrCreate?: UserCreateOrConnectWithoutProcedureTimeslotInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutProcedureTimeslotNestedInput = {
    create?: XOR<UserCreateWithoutProcedureTimeslotInput, UserUncheckedCreateWithoutProcedureTimeslotInput>
    connectOrCreate?: UserCreateOrConnectWithoutProcedureTimeslotInput
    upsert?: UserUpsertWithoutProcedureTimeslotInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutProcedureTimeslotInput, UserUpdateWithoutProcedureTimeslotInput>, UserUncheckedUpdateWithoutProcedureTimeslotInput>
  }

  export type PatientCreateNestedOneWithoutConversationInput = {
    create?: XOR<PatientCreateWithoutConversationInput, PatientUncheckedCreateWithoutConversationInput>
    connectOrCreate?: PatientCreateOrConnectWithoutConversationInput
    connect?: PatientWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutPatientConversationsInput = {
    create?: XOR<UserCreateWithoutPatientConversationsInput, UserUncheckedCreateWithoutPatientConversationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPatientConversationsInput
    connect?: UserWhereUniqueInput
  }

  export type PatientUpdateOneRequiredWithoutConversationNestedInput = {
    create?: XOR<PatientCreateWithoutConversationInput, PatientUncheckedCreateWithoutConversationInput>
    connectOrCreate?: PatientCreateOrConnectWithoutConversationInput
    upsert?: PatientUpsertWithoutConversationInput
    connect?: PatientWhereUniqueInput
    update?: XOR<XOR<PatientUpdateToOneWithWhereWithoutConversationInput, PatientUpdateWithoutConversationInput>, PatientUncheckedUpdateWithoutConversationInput>
  }

  export type UserUpdateOneRequiredWithoutPatientConversationsNestedInput = {
    create?: XOR<UserCreateWithoutPatientConversationsInput, UserUncheckedCreateWithoutPatientConversationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPatientConversationsInput
    upsert?: UserUpsertWithoutPatientConversationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPatientConversationsInput, UserUpdateWithoutPatientConversationsInput>, UserUncheckedUpdateWithoutPatientConversationsInput>
  }

  export type NpiProviderCreateNestedOneWithoutCommissionBatchesInput = {
    create?: XOR<NpiProviderCreateWithoutCommissionBatchesInput, NpiProviderUncheckedCreateWithoutCommissionBatchesInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutCommissionBatchesInput
    connect?: NpiProviderWhereUniqueInput
  }

  export type CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput = {
    create?: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput> | CommissionBatchItemCreateWithoutCommissionBatchInput[] | CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput | CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput[]
    createMany?: CommissionBatchItemCreateManyCommissionBatchInputEnvelope
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
  }

  export type CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput = {
    create?: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput> | CommissionBatchItemCreateWithoutCommissionBatchInput[] | CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput | CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput[]
    createMany?: CommissionBatchItemCreateManyCommissionBatchInputEnvelope
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
  }

  export type NpiProviderUpdateOneRequiredWithoutCommissionBatchesNestedInput = {
    create?: XOR<NpiProviderCreateWithoutCommissionBatchesInput, NpiProviderUncheckedCreateWithoutCommissionBatchesInput>
    connectOrCreate?: NpiProviderCreateOrConnectWithoutCommissionBatchesInput
    upsert?: NpiProviderUpsertWithoutCommissionBatchesInput
    connect?: NpiProviderWhereUniqueInput
    update?: XOR<XOR<NpiProviderUpdateToOneWithWhereWithoutCommissionBatchesInput, NpiProviderUpdateWithoutCommissionBatchesInput>, NpiProviderUncheckedUpdateWithoutCommissionBatchesInput>
  }

  export type CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput = {
    create?: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput> | CommissionBatchItemCreateWithoutCommissionBatchInput[] | CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput | CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput[]
    upsert?: CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput | CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput[]
    createMany?: CommissionBatchItemCreateManyCommissionBatchInputEnvelope
    set?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    disconnect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    delete?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    update?: CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput | CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput[]
    updateMany?: CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput | CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput[]
    deleteMany?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
  }

  export type CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput = {
    create?: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput> | CommissionBatchItemCreateWithoutCommissionBatchInput[] | CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput[]
    connectOrCreate?: CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput | CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput[]
    upsert?: CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput | CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput[]
    createMany?: CommissionBatchItemCreateManyCommissionBatchInputEnvelope
    set?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    disconnect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    delete?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    connect?: CommissionBatchItemWhereUniqueInput | CommissionBatchItemWhereUniqueInput[]
    update?: CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput | CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput[]
    updateMany?: CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput | CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput[]
    deleteMany?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
  }

  export type CommissionBatchCreateNestedOneWithoutItemsInput = {
    create?: XOR<CommissionBatchCreateWithoutItemsInput, CommissionBatchUncheckedCreateWithoutItemsInput>
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutItemsInput
    connect?: CommissionBatchWhereUniqueInput
  }

  export type PaymentCreateNestedOneWithoutCommissionBatchItemsInput = {
    create?: XOR<PaymentCreateWithoutCommissionBatchItemsInput, PaymentUncheckedCreateWithoutCommissionBatchItemsInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutCommissionBatchItemsInput
    connect?: PaymentWhereUniqueInput
  }

  export type CommissionBatchUpdateOneRequiredWithoutItemsNestedInput = {
    create?: XOR<CommissionBatchCreateWithoutItemsInput, CommissionBatchUncheckedCreateWithoutItemsInput>
    connectOrCreate?: CommissionBatchCreateOrConnectWithoutItemsInput
    upsert?: CommissionBatchUpsertWithoutItemsInput
    connect?: CommissionBatchWhereUniqueInput
    update?: XOR<XOR<CommissionBatchUpdateToOneWithWhereWithoutItemsInput, CommissionBatchUpdateWithoutItemsInput>, CommissionBatchUncheckedUpdateWithoutItemsInput>
  }

  export type PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInput = {
    create?: XOR<PaymentCreateWithoutCommissionBatchItemsInput, PaymentUncheckedCreateWithoutCommissionBatchItemsInput>
    connectOrCreate?: PaymentCreateOrConnectWithoutCommissionBatchItemsInput
    upsert?: PaymentUpsertWithoutCommissionBatchItemsInput
    connect?: PaymentWhereUniqueInput
    update?: XOR<XOR<PaymentUpdateToOneWithWhereWithoutCommissionBatchItemsInput, PaymentUpdateWithoutCommissionBatchItemsInput>, PaymentUncheckedUpdateWithoutCommissionBatchItemsInput>
  }

  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 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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  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 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 NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  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 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 NestedEnumPatientStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PatientStatus | EnumPatientStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPatientStatusFilter<$PrismaModel> | $Enums.PatientStatus
  }

  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 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 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 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 NestedEnumPatientStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PatientStatus | EnumPatientStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PatientStatus[] | ListEnumPatientStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPatientStatusWithAggregatesFilter<$PrismaModel> | $Enums.PatientStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPatientStatusFilter<$PrismaModel>
    _max?: NestedEnumPatientStatusFilter<$PrismaModel>
  }

  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 NestedDecimalNullableFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
  }

  export type NestedEnumProcedureSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.ProcedureSource | EnumProcedureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumProcedureSourceFilter<$PrismaModel> | $Enums.ProcedureSource
  }

  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 NestedDecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedDecimalNullableFilter<$PrismaModel>
    _sum?: NestedDecimalNullableFilter<$PrismaModel>
    _min?: NestedDecimalNullableFilter<$PrismaModel>
    _max?: NestedDecimalNullableFilter<$PrismaModel>
  }

  export type NestedEnumProcedureSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ProcedureSource | EnumProcedureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProcedureSource[] | ListEnumProcedureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumProcedureSourceWithAggregatesFilter<$PrismaModel> | $Enums.ProcedureSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProcedureSourceFilter<$PrismaModel>
    _max?: NestedEnumProcedureSourceFilter<$PrismaModel>
  }

  export type NestedEnumMissingTeethStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.MissingTeethStatus | EnumMissingTeethStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMissingTeethStatusFilter<$PrismaModel> | $Enums.MissingTeethStatus
  }

  export type NestedEnumClaimStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ClaimStatus | EnumClaimStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumClaimStatusFilter<$PrismaModel> | $Enums.ClaimStatus
  }

  export type NestedEnumMissingTeethStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MissingTeethStatus | EnumMissingTeethStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MissingTeethStatus[] | ListEnumMissingTeethStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMissingTeethStatusWithAggregatesFilter<$PrismaModel> | $Enums.MissingTeethStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMissingTeethStatusFilter<$PrismaModel>
    _max?: NestedEnumMissingTeethStatusFilter<$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[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumClaimStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ClaimStatus | EnumClaimStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ClaimStatus[] | ListEnumClaimStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumClaimStatusWithAggregatesFilter<$PrismaModel> | $Enums.ClaimStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumClaimStatusFilter<$PrismaModel>
    _max?: NestedEnumClaimStatusFilter<$PrismaModel>
  }

  export type NestedDecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type NestedEnumServiceLineStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ServiceLineStatus | EnumServiceLineStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumServiceLineStatusFilter<$PrismaModel> | $Enums.ServiceLineStatus
  }

  export type NestedDecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type NestedEnumServiceLineStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ServiceLineStatus | EnumServiceLineStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ServiceLineStatus[] | ListEnumServiceLineStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumServiceLineStatusWithAggregatesFilter<$PrismaModel> | $Enums.ServiceLineStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumServiceLineStatusFilter<$PrismaModel>
    _max?: NestedEnumServiceLineStatusFilter<$PrismaModel>
  }

  export type NestedEnumPdfTitleKeyFilter<$PrismaModel = never> = {
    equals?: $Enums.PdfTitleKey | EnumPdfTitleKeyFieldRefInput<$PrismaModel>
    in?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    notIn?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    not?: NestedEnumPdfTitleKeyFilter<$PrismaModel> | $Enums.PdfTitleKey
  }

  export type NestedEnumPdfTitleKeyWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PdfTitleKey | EnumPdfTitleKeyFieldRefInput<$PrismaModel>
    in?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    notIn?: $Enums.PdfTitleKey[] | ListEnumPdfTitleKeyFieldRefInput<$PrismaModel>
    not?: NestedEnumPdfTitleKeyWithAggregatesFilter<$PrismaModel> | $Enums.PdfTitleKey
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPdfTitleKeyFilter<$PrismaModel>
    _max?: NestedEnumPdfTitleKeyFilter<$PrismaModel>
  }

  export type NestedBytesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesFilter<$PrismaModel> | Bytes
  }

  export type NestedBytesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesWithAggregatesFilter<$PrismaModel> | Bytes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBytesFilter<$PrismaModel>
    _max?: NestedBytesFilter<$PrismaModel>
  }

  export type NestedEnumPaymentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus
  }

  export type NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentStatusFilter<$PrismaModel>
    _max?: NestedEnumPaymentStatusFilter<$PrismaModel>
  }

  export type NestedEnumPaymentMethodFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentMethod | EnumPaymentMethodFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentMethodFilter<$PrismaModel> | $Enums.PaymentMethod
  }

  export type NestedEnumPaymentMethodWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentMethod | EnumPaymentMethodFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentMethod[] | ListEnumPaymentMethodFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentMethodWithAggregatesFilter<$PrismaModel> | $Enums.PaymentMethod
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentMethodFilter<$PrismaModel>
    _max?: NestedEnumPaymentMethodFilter<$PrismaModel>
  }

  export type NestedEnumNotificationTypesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationTypes | EnumNotificationTypesFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationTypesFilter<$PrismaModel> | $Enums.NotificationTypes
  }

  export type NestedEnumNotificationTypesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.NotificationTypes | EnumNotificationTypesFieldRefInput<$PrismaModel>
    in?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    notIn?: $Enums.NotificationTypes[] | ListEnumNotificationTypesFieldRefInput<$PrismaModel>
    not?: NestedEnumNotificationTypesWithAggregatesFilter<$PrismaModel> | $Enums.NotificationTypes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumNotificationTypesFilter<$PrismaModel>
    _max?: NestedEnumNotificationTypesFilter<$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 NestedEnumCommunicationChannelFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationChannel | EnumCommunicationChannelFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationChannelFilter<$PrismaModel> | $Enums.CommunicationChannel
  }

  export type NestedEnumCommunicationDirectionFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationDirection | EnumCommunicationDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationDirectionFilter<$PrismaModel> | $Enums.CommunicationDirection
  }

  export type NestedEnumCommunicationStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationStatus | EnumCommunicationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationStatusFilter<$PrismaModel> | $Enums.CommunicationStatus
  }

  export type NestedEnumCommunicationChannelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationChannel | EnumCommunicationChannelFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationChannel[] | ListEnumCommunicationChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationChannelWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationChannel
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationChannelFilter<$PrismaModel>
    _max?: NestedEnumCommunicationChannelFilter<$PrismaModel>
  }

  export type NestedEnumCommunicationDirectionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationDirection | EnumCommunicationDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationDirection[] | ListEnumCommunicationDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationDirectionWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationDirection
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationDirectionFilter<$PrismaModel>
    _max?: NestedEnumCommunicationDirectionFilter<$PrismaModel>
  }

  export type NestedEnumCommunicationStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommunicationStatus | EnumCommunicationStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommunicationStatus[] | ListEnumCommunicationStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommunicationStatusWithAggregatesFilter<$PrismaModel> | $Enums.CommunicationStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommunicationStatusFilter<$PrismaModel>
    _max?: NestedEnumCommunicationStatusFilter<$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[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type PatientCreateWithoutUserInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutUserInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutUserInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput>
  }

  export type PatientCreateManyUserInputEnvelope = {
    data: PatientCreateManyUserInput | PatientCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentCreateWithoutUserInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutUserInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput>
  }

  export type AppointmentCreateManyUserInputEnvelope = {
    data: AppointmentCreateManyUserInput | AppointmentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type StaffCreateWithoutUserInput = {
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    appointments?: AppointmentCreateNestedManyWithoutStaffInput
    claims?: ClaimCreateNestedManyWithoutStaffInput
  }

  export type StaffUncheckedCreateWithoutUserInput = {
    id?: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutStaffInput
    claims?: ClaimUncheckedCreateNestedManyWithoutStaffInput
  }

  export type StaffCreateOrConnectWithoutUserInput = {
    where: StaffWhereUniqueInput
    create: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput>
  }

  export type StaffCreateManyUserInputEnvelope = {
    data: StaffCreateManyUserInput | StaffCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type NpiProviderCreateWithoutUserInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateWithoutUserInput = {
    id?: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentUncheckedCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderCreateOrConnectWithoutUserInput = {
    where: NpiProviderWhereUniqueInput
    create: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput>
  }

  export type NpiProviderCreateManyUserInputEnvelope = {
    data: NpiProviderCreateManyUserInput | NpiProviderCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ClaimCreateWithoutUserInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutUserInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput>
  }

  export type ClaimCreateManyUserInputEnvelope = {
    data: ClaimCreateManyUserInput | ClaimCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type InsuranceCredentialCreateWithoutUserInput = {
    siteKey: string
    username: string
    password: string
  }

  export type InsuranceCredentialUncheckedCreateWithoutUserInput = {
    id?: number
    siteKey: string
    username: string
    password: string
  }

  export type InsuranceCredentialCreateOrConnectWithoutUserInput = {
    where: InsuranceCredentialWhereUniqueInput
    create: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput>
  }

  export type InsuranceCredentialCreateManyUserInputEnvelope = {
    data: InsuranceCredentialCreateManyUserInput | InsuranceCredentialCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ShoppingVendorCreateWithoutUserInput = {
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
  }

  export type ShoppingVendorUncheckedCreateWithoutUserInput = {
    id?: number
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
  }

  export type ShoppingVendorCreateOrConnectWithoutUserInput = {
    where: ShoppingVendorWhereUniqueInput
    create: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput>
  }

  export type ShoppingVendorCreateManyUserInputEnvelope = {
    data: ShoppingVendorCreateManyUserInput | ShoppingVendorCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type PaymentCreateWithoutUpdatedByInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutUpdatedByInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutUpdatedByInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput>
  }

  export type PaymentCreateManyUpdatedByInputEnvelope = {
    data: PaymentCreateManyUpdatedByInput | PaymentCreateManyUpdatedByInput[]
    skipDuplicates?: boolean
  }

  export type DatabaseBackupCreateWithoutUserInput = {
    createdAt?: Date | string
  }

  export type DatabaseBackupUncheckedCreateWithoutUserInput = {
    id?: number
    createdAt?: Date | string
  }

  export type DatabaseBackupCreateOrConnectWithoutUserInput = {
    where: DatabaseBackupWhereUniqueInput
    create: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput>
  }

  export type DatabaseBackupCreateManyUserInputEnvelope = {
    data: DatabaseBackupCreateManyUserInput | DatabaseBackupCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type BackupDestinationCreateWithoutUserInput = {
    path: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type BackupDestinationUncheckedCreateWithoutUserInput = {
    id?: number
    path: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type BackupDestinationCreateOrConnectWithoutUserInput = {
    where: BackupDestinationWhereUniqueInput
    create: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput>
  }

  export type BackupDestinationCreateManyUserInputEnvelope = {
    data: BackupDestinationCreateManyUserInput | BackupDestinationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type NotificationCreateWithoutUserInput = {
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
  }

  export type NotificationUncheckedCreateWithoutUserInput = {
    id?: number
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
  }

  export type NotificationCreateOrConnectWithoutUserInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput>
  }

  export type NotificationCreateManyUserInputEnvelope = {
    data: NotificationCreateManyUserInput | NotificationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type CloudFolderCreateWithoutUserInput = {
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    parent?: CloudFolderCreateNestedOneWithoutChildrenInput
    children?: CloudFolderCreateNestedManyWithoutParentInput
    files?: CloudFileCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderUncheckedCreateWithoutUserInput = {
    id?: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    children?: CloudFolderUncheckedCreateNestedManyWithoutParentInput
    files?: CloudFileUncheckedCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderCreateOrConnectWithoutUserInput = {
    where: CloudFolderWhereUniqueInput
    create: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput>
  }

  export type CloudFolderCreateManyUserInputEnvelope = {
    data: CloudFolderCreateManyUserInput | CloudFolderCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type CloudFileCreateWithoutUserInput = {
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folder?: CloudFolderCreateNestedOneWithoutFilesInput
    chunks?: CloudFileChunkCreateNestedManyWithoutFileInput
  }

  export type CloudFileUncheckedCreateWithoutUserInput = {
    id?: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    folderId?: number | null
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    chunks?: CloudFileChunkUncheckedCreateNestedManyWithoutFileInput
  }

  export type CloudFileCreateOrConnectWithoutUserInput = {
    where: CloudFileWhereUniqueInput
    create: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput>
  }

  export type CloudFileCreateManyUserInputEnvelope = {
    data: CloudFileCreateManyUserInput | CloudFileCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type CommunicationCreateWithoutUserInput = {
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
    patient: PatientCreateNestedOneWithoutCommunicationsInput
  }

  export type CommunicationUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type CommunicationCreateOrConnectWithoutUserInput = {
    where: CommunicationWhereUniqueInput
    create: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput>
  }

  export type CommunicationCreateManyUserInputEnvelope = {
    data: CommunicationCreateManyUserInput | CommunicationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type TwilioSettingsCreateWithoutUserInput = {
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage?: string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsUncheckedCreateWithoutUserInput = {
    id?: number
    accountSid: string
    authToken: string
    phoneNumber: string
    greetingMessage?: string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsCreateOrConnectWithoutUserInput = {
    where: TwilioSettingsWhereUniqueInput
    create: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
  }

  export type AiSettingsCreateWithoutUserInput = {
    apiKey: string
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
  }

  export type AiSettingsUncheckedCreateWithoutUserInput = {
    id?: number
    apiKey: string
    afterHoursEnabled?: boolean
    openPhoneReply?: boolean
  }

  export type AiSettingsCreateOrConnectWithoutUserInput = {
    where: AiSettingsWhereUniqueInput
    create: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
  }

  export type OfficeHoursCreateWithoutUserInput = {
    data: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursUncheckedCreateWithoutUserInput = {
    id?: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursCreateOrConnectWithoutUserInput = {
    where: OfficeHoursWhereUniqueInput
    create: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
  }

  export type OfficeContactCreateWithoutUserInput = {
    officeName?: string | null
    receptionistName?: string | null
    dentistName?: string | null
    phoneNumber?: string | null
    email?: string | null
    fax?: string | null
    streetAddress?: string | null
    city?: string | null
    state?: string | null
    zipCode?: string | null
  }

  export type OfficeContactUncheckedCreateWithoutUserInput = {
    id?: number
    officeName?: string | null
    receptionistName?: string | null
    dentistName?: string | null
    phoneNumber?: string | null
    email?: string | null
    fax?: string | null
    streetAddress?: string | null
    city?: string | null
    state?: string | null
    zipCode?: string | null
  }

  export type OfficeContactCreateOrConnectWithoutUserInput = {
    where: OfficeContactWhereUniqueInput
    create: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
  }

  export type ProcedureTimeslotCreateWithoutUserInput = {
    data: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotUncheckedCreateWithoutUserInput = {
    id?: number
    data: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotCreateOrConnectWithoutUserInput = {
    where: ProcedureTimeslotWhereUniqueInput
    create: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
  }

  export type InsuranceContactCreateWithoutUserInput = {
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
  }

  export type InsuranceContactUncheckedCreateWithoutUserInput = {
    id?: number
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
  }

  export type InsuranceContactCreateOrConnectWithoutUserInput = {
    where: InsuranceContactWhereUniqueInput
    create: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput>
  }

  export type InsuranceContactCreateManyUserInputEnvelope = {
    data: InsuranceContactCreateManyUserInput | InsuranceContactCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type PatientConversationCreateWithoutUserInput = {
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
    patient: PatientCreateNestedOneWithoutConversationInput
  }

  export type PatientConversationUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
  }

  export type PatientConversationCreateOrConnectWithoutUserInput = {
    where: PatientConversationWhereUniqueInput
    create: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput>
  }

  export type PatientConversationCreateManyUserInputEnvelope = {
    data: PatientConversationCreateManyUserInput | PatientConversationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type PatientUpsertWithWhereUniqueWithoutUserInput = {
    where: PatientWhereUniqueInput
    update: XOR<PatientUpdateWithoutUserInput, PatientUncheckedUpdateWithoutUserInput>
    create: XOR<PatientCreateWithoutUserInput, PatientUncheckedCreateWithoutUserInput>
  }

  export type PatientUpdateWithWhereUniqueWithoutUserInput = {
    where: PatientWhereUniqueInput
    data: XOR<PatientUpdateWithoutUserInput, PatientUncheckedUpdateWithoutUserInput>
  }

  export type PatientUpdateManyWithWhereWithoutUserInput = {
    where: PatientScalarWhereInput
    data: XOR<PatientUpdateManyMutationInput, PatientUncheckedUpdateManyWithoutUserInput>
  }

  export type PatientScalarWhereInput = {
    AND?: PatientScalarWhereInput | PatientScalarWhereInput[]
    OR?: PatientScalarWhereInput[]
    NOT?: PatientScalarWhereInput | PatientScalarWhereInput[]
    id?: IntFilter<"Patient"> | number
    firstName?: StringFilter<"Patient"> | string
    lastName?: StringFilter<"Patient"> | string
    dateOfBirth?: DateTimeNullableFilter<"Patient"> | Date | string | null
    gender?: StringFilter<"Patient"> | string
    phone?: StringFilter<"Patient"> | string
    email?: StringNullableFilter<"Patient"> | string | null
    address?: StringNullableFilter<"Patient"> | string | null
    city?: StringNullableFilter<"Patient"> | string | null
    zipCode?: StringNullableFilter<"Patient"> | string | null
    insuranceProvider?: StringNullableFilter<"Patient"> | string | null
    insuranceId?: StringNullableFilter<"Patient"> | string | null
    groupNumber?: StringNullableFilter<"Patient"> | string | null
    policyHolder?: StringNullableFilter<"Patient"> | string | null
    allergies?: StringNullableFilter<"Patient"> | string | null
    medicalConditions?: StringNullableFilter<"Patient"> | string | null
    preferredLanguage?: StringNullableFilter<"Patient"> | string | null
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: DateTimeFilter<"Patient"> | Date | string
    updatedAt?: DateTimeFilter<"Patient"> | Date | string
  }

  export type AppointmentUpsertWithWhereUniqueWithoutUserInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutUserInput, AppointmentUncheckedUpdateWithoutUserInput>
    create: XOR<AppointmentCreateWithoutUserInput, AppointmentUncheckedCreateWithoutUserInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutUserInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutUserInput, AppointmentUncheckedUpdateWithoutUserInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutUserInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutUserInput>
  }

  export type AppointmentScalarWhereInput = {
    AND?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    OR?: AppointmentScalarWhereInput[]
    NOT?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    id?: IntFilter<"Appointment"> | number
    patientId?: IntFilter<"Appointment"> | number
    userId?: IntFilter<"Appointment"> | number
    staffId?: IntFilter<"Appointment"> | number
    title?: StringFilter<"Appointment"> | string
    date?: DateTimeFilter<"Appointment"> | Date | string
    startTime?: StringFilter<"Appointment"> | string
    endTime?: StringFilter<"Appointment"> | string
    type?: StringFilter<"Appointment"> | string
    typeLocked?: BoolFilter<"Appointment"> | boolean
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    movedByAi?: BoolFilter<"Appointment"> | boolean
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    eligibilityStatus?: EnumPatientStatusFilter<"Appointment"> | $Enums.PatientStatus
  }

  export type StaffUpsertWithWhereUniqueWithoutUserInput = {
    where: StaffWhereUniqueInput
    update: XOR<StaffUpdateWithoutUserInput, StaffUncheckedUpdateWithoutUserInput>
    create: XOR<StaffCreateWithoutUserInput, StaffUncheckedCreateWithoutUserInput>
  }

  export type StaffUpdateWithWhereUniqueWithoutUserInput = {
    where: StaffWhereUniqueInput
    data: XOR<StaffUpdateWithoutUserInput, StaffUncheckedUpdateWithoutUserInput>
  }

  export type StaffUpdateManyWithWhereWithoutUserInput = {
    where: StaffScalarWhereInput
    data: XOR<StaffUpdateManyMutationInput, StaffUncheckedUpdateManyWithoutUserInput>
  }

  export type StaffScalarWhereInput = {
    AND?: StaffScalarWhereInput | StaffScalarWhereInput[]
    OR?: StaffScalarWhereInput[]
    NOT?: StaffScalarWhereInput | StaffScalarWhereInput[]
    id?: IntFilter<"Staff"> | number
    userId?: IntFilter<"Staff"> | number
    name?: StringFilter<"Staff"> | string
    email?: StringNullableFilter<"Staff"> | string | null
    role?: StringFilter<"Staff"> | string
    phone?: StringNullableFilter<"Staff"> | string | null
    createdAt?: DateTimeFilter<"Staff"> | Date | string
  }

  export type NpiProviderUpsertWithWhereUniqueWithoutUserInput = {
    where: NpiProviderWhereUniqueInput
    update: XOR<NpiProviderUpdateWithoutUserInput, NpiProviderUncheckedUpdateWithoutUserInput>
    create: XOR<NpiProviderCreateWithoutUserInput, NpiProviderUncheckedCreateWithoutUserInput>
  }

  export type NpiProviderUpdateWithWhereUniqueWithoutUserInput = {
    where: NpiProviderWhereUniqueInput
    data: XOR<NpiProviderUpdateWithoutUserInput, NpiProviderUncheckedUpdateWithoutUserInput>
  }

  export type NpiProviderUpdateManyWithWhereWithoutUserInput = {
    where: NpiProviderScalarWhereInput
    data: XOR<NpiProviderUpdateManyMutationInput, NpiProviderUncheckedUpdateManyWithoutUserInput>
  }

  export type NpiProviderScalarWhereInput = {
    AND?: NpiProviderScalarWhereInput | NpiProviderScalarWhereInput[]
    OR?: NpiProviderScalarWhereInput[]
    NOT?: NpiProviderScalarWhereInput | NpiProviderScalarWhereInput[]
    id?: IntFilter<"NpiProvider"> | number
    userId?: IntFilter<"NpiProvider"> | number
    npiNumber?: StringFilter<"NpiProvider"> | string
    providerName?: StringFilter<"NpiProvider"> | string
    createdAt?: DateTimeFilter<"NpiProvider"> | Date | string
  }

  export type ClaimUpsertWithWhereUniqueWithoutUserInput = {
    where: ClaimWhereUniqueInput
    update: XOR<ClaimUpdateWithoutUserInput, ClaimUncheckedUpdateWithoutUserInput>
    create: XOR<ClaimCreateWithoutUserInput, ClaimUncheckedCreateWithoutUserInput>
  }

  export type ClaimUpdateWithWhereUniqueWithoutUserInput = {
    where: ClaimWhereUniqueInput
    data: XOR<ClaimUpdateWithoutUserInput, ClaimUncheckedUpdateWithoutUserInput>
  }

  export type ClaimUpdateManyWithWhereWithoutUserInput = {
    where: ClaimScalarWhereInput
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutUserInput>
  }

  export type ClaimScalarWhereInput = {
    AND?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
    OR?: ClaimScalarWhereInput[]
    NOT?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
    id?: IntFilter<"Claim"> | number
    patientId?: IntFilter<"Claim"> | number
    appointmentId?: IntNullableFilter<"Claim"> | number | null
    userId?: IntFilter<"Claim"> | number
    staffId?: IntFilter<"Claim"> | number
    patientName?: StringFilter<"Claim"> | string
    memberId?: StringFilter<"Claim"> | string
    dateOfBirth?: DateTimeFilter<"Claim"> | Date | string
    remarks?: StringFilter<"Claim"> | string
    missingTeethStatus?: EnumMissingTeethStatusFilter<"Claim"> | $Enums.MissingTeethStatus
    missingTeeth?: JsonNullableFilter<"Claim">
    serviceDate?: DateTimeFilter<"Claim"> | Date | string
    insuranceProvider?: StringFilter<"Claim"> | string
    createdAt?: DateTimeFilter<"Claim"> | Date | string
    updatedAt?: DateTimeFilter<"Claim"> | Date | string
    status?: EnumClaimStatusFilter<"Claim"> | $Enums.ClaimStatus
    claimNumber?: StringNullableFilter<"Claim"> | string | null
    preAuthNumber?: StringNullableFilter<"Claim"> | string | null
    npiProviderId?: IntNullableFilter<"Claim"> | number | null
  }

  export type InsuranceCredentialUpsertWithWhereUniqueWithoutUserInput = {
    where: InsuranceCredentialWhereUniqueInput
    update: XOR<InsuranceCredentialUpdateWithoutUserInput, InsuranceCredentialUncheckedUpdateWithoutUserInput>
    create: XOR<InsuranceCredentialCreateWithoutUserInput, InsuranceCredentialUncheckedCreateWithoutUserInput>
  }

  export type InsuranceCredentialUpdateWithWhereUniqueWithoutUserInput = {
    where: InsuranceCredentialWhereUniqueInput
    data: XOR<InsuranceCredentialUpdateWithoutUserInput, InsuranceCredentialUncheckedUpdateWithoutUserInput>
  }

  export type InsuranceCredentialUpdateManyWithWhereWithoutUserInput = {
    where: InsuranceCredentialScalarWhereInput
    data: XOR<InsuranceCredentialUpdateManyMutationInput, InsuranceCredentialUncheckedUpdateManyWithoutUserInput>
  }

  export type InsuranceCredentialScalarWhereInput = {
    AND?: InsuranceCredentialScalarWhereInput | InsuranceCredentialScalarWhereInput[]
    OR?: InsuranceCredentialScalarWhereInput[]
    NOT?: InsuranceCredentialScalarWhereInput | InsuranceCredentialScalarWhereInput[]
    id?: IntFilter<"InsuranceCredential"> | number
    userId?: IntFilter<"InsuranceCredential"> | number
    siteKey?: StringFilter<"InsuranceCredential"> | string
    username?: StringFilter<"InsuranceCredential"> | string
    password?: StringFilter<"InsuranceCredential"> | string
  }

  export type ShoppingVendorUpsertWithWhereUniqueWithoutUserInput = {
    where: ShoppingVendorWhereUniqueInput
    update: XOR<ShoppingVendorUpdateWithoutUserInput, ShoppingVendorUncheckedUpdateWithoutUserInput>
    create: XOR<ShoppingVendorCreateWithoutUserInput, ShoppingVendorUncheckedCreateWithoutUserInput>
  }

  export type ShoppingVendorUpdateWithWhereUniqueWithoutUserInput = {
    where: ShoppingVendorWhereUniqueInput
    data: XOR<ShoppingVendorUpdateWithoutUserInput, ShoppingVendorUncheckedUpdateWithoutUserInput>
  }

  export type ShoppingVendorUpdateManyWithWhereWithoutUserInput = {
    where: ShoppingVendorScalarWhereInput
    data: XOR<ShoppingVendorUpdateManyMutationInput, ShoppingVendorUncheckedUpdateManyWithoutUserInput>
  }

  export type ShoppingVendorScalarWhereInput = {
    AND?: ShoppingVendorScalarWhereInput | ShoppingVendorScalarWhereInput[]
    OR?: ShoppingVendorScalarWhereInput[]
    NOT?: ShoppingVendorScalarWhereInput | ShoppingVendorScalarWhereInput[]
    id?: IntFilter<"ShoppingVendor"> | number
    userId?: IntFilter<"ShoppingVendor"> | number
    vendorName?: StringFilter<"ShoppingVendor"> | string
    websiteUrl?: StringFilter<"ShoppingVendor"> | string
    loginUsername?: StringFilter<"ShoppingVendor"> | string
    loginPassword?: StringFilter<"ShoppingVendor"> | string
  }

  export type PaymentUpsertWithWhereUniqueWithoutUpdatedByInput = {
    where: PaymentWhereUniqueInput
    update: XOR<PaymentUpdateWithoutUpdatedByInput, PaymentUncheckedUpdateWithoutUpdatedByInput>
    create: XOR<PaymentCreateWithoutUpdatedByInput, PaymentUncheckedCreateWithoutUpdatedByInput>
  }

  export type PaymentUpdateWithWhereUniqueWithoutUpdatedByInput = {
    where: PaymentWhereUniqueInput
    data: XOR<PaymentUpdateWithoutUpdatedByInput, PaymentUncheckedUpdateWithoutUpdatedByInput>
  }

  export type PaymentUpdateManyWithWhereWithoutUpdatedByInput = {
    where: PaymentScalarWhereInput
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyWithoutUpdatedByInput>
  }

  export type PaymentScalarWhereInput = {
    AND?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
    OR?: PaymentScalarWhereInput[]
    NOT?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
    id?: IntFilter<"Payment"> | number
    claimId?: IntNullableFilter<"Payment"> | number | null
    patientId?: IntFilter<"Payment"> | number
    userId?: IntFilter<"Payment"> | number
    updatedById?: IntNullableFilter<"Payment"> | number | null
    npiProviderId?: IntNullableFilter<"Payment"> | number | null
    totalBilled?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: DecimalNullableFilter<"Payment"> | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFilter<"Payment"> | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    notes?: StringNullableFilter<"Payment"> | string | null
    icn?: StringNullableFilter<"Payment"> | string | null
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
  }

  export type DatabaseBackupUpsertWithWhereUniqueWithoutUserInput = {
    where: DatabaseBackupWhereUniqueInput
    update: XOR<DatabaseBackupUpdateWithoutUserInput, DatabaseBackupUncheckedUpdateWithoutUserInput>
    create: XOR<DatabaseBackupCreateWithoutUserInput, DatabaseBackupUncheckedCreateWithoutUserInput>
  }

  export type DatabaseBackupUpdateWithWhereUniqueWithoutUserInput = {
    where: DatabaseBackupWhereUniqueInput
    data: XOR<DatabaseBackupUpdateWithoutUserInput, DatabaseBackupUncheckedUpdateWithoutUserInput>
  }

  export type DatabaseBackupUpdateManyWithWhereWithoutUserInput = {
    where: DatabaseBackupScalarWhereInput
    data: XOR<DatabaseBackupUpdateManyMutationInput, DatabaseBackupUncheckedUpdateManyWithoutUserInput>
  }

  export type DatabaseBackupScalarWhereInput = {
    AND?: DatabaseBackupScalarWhereInput | DatabaseBackupScalarWhereInput[]
    OR?: DatabaseBackupScalarWhereInput[]
    NOT?: DatabaseBackupScalarWhereInput | DatabaseBackupScalarWhereInput[]
    id?: IntFilter<"DatabaseBackup"> | number
    userId?: IntFilter<"DatabaseBackup"> | number
    createdAt?: DateTimeFilter<"DatabaseBackup"> | Date | string
  }

  export type BackupDestinationUpsertWithWhereUniqueWithoutUserInput = {
    where: BackupDestinationWhereUniqueInput
    update: XOR<BackupDestinationUpdateWithoutUserInput, BackupDestinationUncheckedUpdateWithoutUserInput>
    create: XOR<BackupDestinationCreateWithoutUserInput, BackupDestinationUncheckedCreateWithoutUserInput>
  }

  export type BackupDestinationUpdateWithWhereUniqueWithoutUserInput = {
    where: BackupDestinationWhereUniqueInput
    data: XOR<BackupDestinationUpdateWithoutUserInput, BackupDestinationUncheckedUpdateWithoutUserInput>
  }

  export type BackupDestinationUpdateManyWithWhereWithoutUserInput = {
    where: BackupDestinationScalarWhereInput
    data: XOR<BackupDestinationUpdateManyMutationInput, BackupDestinationUncheckedUpdateManyWithoutUserInput>
  }

  export type BackupDestinationScalarWhereInput = {
    AND?: BackupDestinationScalarWhereInput | BackupDestinationScalarWhereInput[]
    OR?: BackupDestinationScalarWhereInput[]
    NOT?: BackupDestinationScalarWhereInput | BackupDestinationScalarWhereInput[]
    id?: IntFilter<"BackupDestination"> | number
    userId?: IntFilter<"BackupDestination"> | number
    path?: StringFilter<"BackupDestination"> | string
    isActive?: BoolFilter<"BackupDestination"> | boolean
    createdAt?: DateTimeFilter<"BackupDestination"> | Date | string
  }

  export type NotificationUpsertWithWhereUniqueWithoutUserInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutUserInput, NotificationUncheckedUpdateWithoutUserInput>
    create: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutUserInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutUserInput, NotificationUncheckedUpdateWithoutUserInput>
  }

  export type NotificationUpdateManyWithWhereWithoutUserInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutUserInput>
  }

  export type NotificationScalarWhereInput = {
    AND?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    OR?: NotificationScalarWhereInput[]
    NOT?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    id?: IntFilter<"Notification"> | number
    userId?: IntFilter<"Notification"> | number
    type?: EnumNotificationTypesFilter<"Notification"> | $Enums.NotificationTypes
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    read?: BoolFilter<"Notification"> | boolean
  }

  export type CloudFolderUpsertWithWhereUniqueWithoutUserInput = {
    where: CloudFolderWhereUniqueInput
    update: XOR<CloudFolderUpdateWithoutUserInput, CloudFolderUncheckedUpdateWithoutUserInput>
    create: XOR<CloudFolderCreateWithoutUserInput, CloudFolderUncheckedCreateWithoutUserInput>
  }

  export type CloudFolderUpdateWithWhereUniqueWithoutUserInput = {
    where: CloudFolderWhereUniqueInput
    data: XOR<CloudFolderUpdateWithoutUserInput, CloudFolderUncheckedUpdateWithoutUserInput>
  }

  export type CloudFolderUpdateManyWithWhereWithoutUserInput = {
    where: CloudFolderScalarWhereInput
    data: XOR<CloudFolderUpdateManyMutationInput, CloudFolderUncheckedUpdateManyWithoutUserInput>
  }

  export type CloudFolderScalarWhereInput = {
    AND?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
    OR?: CloudFolderScalarWhereInput[]
    NOT?: CloudFolderScalarWhereInput | CloudFolderScalarWhereInput[]
    id?: IntFilter<"CloudFolder"> | number
    userId?: IntFilter<"CloudFolder"> | number
    name?: StringFilter<"CloudFolder"> | string
    parentId?: IntNullableFilter<"CloudFolder"> | number | null
    createdAt?: DateTimeFilter<"CloudFolder"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFolder"> | Date | string
  }

  export type CloudFileUpsertWithWhereUniqueWithoutUserInput = {
    where: CloudFileWhereUniqueInput
    update: XOR<CloudFileUpdateWithoutUserInput, CloudFileUncheckedUpdateWithoutUserInput>
    create: XOR<CloudFileCreateWithoutUserInput, CloudFileUncheckedCreateWithoutUserInput>
  }

  export type CloudFileUpdateWithWhereUniqueWithoutUserInput = {
    where: CloudFileWhereUniqueInput
    data: XOR<CloudFileUpdateWithoutUserInput, CloudFileUncheckedUpdateWithoutUserInput>
  }

  export type CloudFileUpdateManyWithWhereWithoutUserInput = {
    where: CloudFileScalarWhereInput
    data: XOR<CloudFileUpdateManyMutationInput, CloudFileUncheckedUpdateManyWithoutUserInput>
  }

  export type CloudFileScalarWhereInput = {
    AND?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
    OR?: CloudFileScalarWhereInput[]
    NOT?: CloudFileScalarWhereInput | CloudFileScalarWhereInput[]
    id?: IntFilter<"CloudFile"> | number
    userId?: IntFilter<"CloudFile"> | number
    name?: StringFilter<"CloudFile"> | string
    mimeType?: StringNullableFilter<"CloudFile"> | string | null
    fileSize?: BigIntFilter<"CloudFile"> | bigint | number
    folderId?: IntNullableFilter<"CloudFile"> | number | null
    isComplete?: BoolFilter<"CloudFile"> | boolean
    totalChunks?: IntNullableFilter<"CloudFile"> | number | null
    diskPath?: StringNullableFilter<"CloudFile"> | string | null
    createdAt?: DateTimeFilter<"CloudFile"> | Date | string
    updatedAt?: DateTimeFilter<"CloudFile"> | Date | string
  }

  export type CommunicationUpsertWithWhereUniqueWithoutUserInput = {
    where: CommunicationWhereUniqueInput
    update: XOR<CommunicationUpdateWithoutUserInput, CommunicationUncheckedUpdateWithoutUserInput>
    create: XOR<CommunicationCreateWithoutUserInput, CommunicationUncheckedCreateWithoutUserInput>
  }

  export type CommunicationUpdateWithWhereUniqueWithoutUserInput = {
    where: CommunicationWhereUniqueInput
    data: XOR<CommunicationUpdateWithoutUserInput, CommunicationUncheckedUpdateWithoutUserInput>
  }

  export type CommunicationUpdateManyWithWhereWithoutUserInput = {
    where: CommunicationScalarWhereInput
    data: XOR<CommunicationUpdateManyMutationInput, CommunicationUncheckedUpdateManyWithoutUserInput>
  }

  export type CommunicationScalarWhereInput = {
    AND?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
    OR?: CommunicationScalarWhereInput[]
    NOT?: CommunicationScalarWhereInput | CommunicationScalarWhereInput[]
    id?: IntFilter<"Communication"> | number
    patientId?: IntFilter<"Communication"> | number
    userId?: IntNullableFilter<"Communication"> | number | null
    channel?: EnumCommunicationChannelFilter<"Communication"> | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFilter<"Communication"> | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFilter<"Communication"> | $Enums.CommunicationStatus
    body?: StringNullableFilter<"Communication"> | string | null
    callDuration?: IntNullableFilter<"Communication"> | number | null
    twilioSid?: StringNullableFilter<"Communication"> | string | null
    createdAt?: DateTimeFilter<"Communication"> | Date | string
  }

  export type TwilioSettingsUpsertWithoutUserInput = {
    update: XOR<TwilioSettingsUpdateWithoutUserInput, TwilioSettingsUncheckedUpdateWithoutUserInput>
    create: XOR<TwilioSettingsCreateWithoutUserInput, TwilioSettingsUncheckedCreateWithoutUserInput>
    where?: TwilioSettingsWhereInput
  }

  export type TwilioSettingsUpdateToOneWithWhereWithoutUserInput = {
    where?: TwilioSettingsWhereInput
    data: XOR<TwilioSettingsUpdateWithoutUserInput, TwilioSettingsUncheckedUpdateWithoutUserInput>
  }

  export type TwilioSettingsUpdateWithoutUserInput = {
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type TwilioSettingsUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    accountSid?: StringFieldUpdateOperationsInput | string
    authToken?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    greetingMessage?: NullableStringFieldUpdateOperationsInput | string | null
    templates?: NullableJsonNullValueInput | InputJsonValue
  }

  export type AiSettingsUpsertWithoutUserInput = {
    update: XOR<AiSettingsUpdateWithoutUserInput, AiSettingsUncheckedUpdateWithoutUserInput>
    create: XOR<AiSettingsCreateWithoutUserInput, AiSettingsUncheckedCreateWithoutUserInput>
    where?: AiSettingsWhereInput
  }

  export type AiSettingsUpdateToOneWithWhereWithoutUserInput = {
    where?: AiSettingsWhereInput
    data: XOR<AiSettingsUpdateWithoutUserInput, AiSettingsUncheckedUpdateWithoutUserInput>
  }

  export type AiSettingsUpdateWithoutUserInput = {
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
  }

  export type AiSettingsUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    apiKey?: StringFieldUpdateOperationsInput | string
    afterHoursEnabled?: BoolFieldUpdateOperationsInput | boolean
    openPhoneReply?: BoolFieldUpdateOperationsInput | boolean
  }

  export type OfficeHoursUpsertWithoutUserInput = {
    update: XOR<OfficeHoursUpdateWithoutUserInput, OfficeHoursUncheckedUpdateWithoutUserInput>
    create: XOR<OfficeHoursCreateWithoutUserInput, OfficeHoursUncheckedCreateWithoutUserInput>
    where?: OfficeHoursWhereInput
  }

  export type OfficeHoursUpdateToOneWithWhereWithoutUserInput = {
    where?: OfficeHoursWhereInput
    data: XOR<OfficeHoursUpdateWithoutUserInput, OfficeHoursUncheckedUpdateWithoutUserInput>
  }

  export type OfficeHoursUpdateWithoutUserInput = {
    data?: JsonNullValueInput | InputJsonValue
  }

  export type OfficeHoursUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type OfficeContactUpsertWithoutUserInput = {
    update: XOR<OfficeContactUpdateWithoutUserInput, OfficeContactUncheckedUpdateWithoutUserInput>
    create: XOR<OfficeContactCreateWithoutUserInput, OfficeContactUncheckedCreateWithoutUserInput>
    where?: OfficeContactWhereInput
  }

  export type OfficeContactUpdateToOneWithWhereWithoutUserInput = {
    where?: OfficeContactWhereInput
    data: XOR<OfficeContactUpdateWithoutUserInput, OfficeContactUncheckedUpdateWithoutUserInput>
  }

  export type OfficeContactUpdateWithoutUserInput = {
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OfficeContactUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    officeName?: NullableStringFieldUpdateOperationsInput | string | null
    receptionistName?: NullableStringFieldUpdateOperationsInput | string | null
    dentistName?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    fax?: NullableStringFieldUpdateOperationsInput | string | null
    streetAddress?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ProcedureTimeslotUpsertWithoutUserInput = {
    update: XOR<ProcedureTimeslotUpdateWithoutUserInput, ProcedureTimeslotUncheckedUpdateWithoutUserInput>
    create: XOR<ProcedureTimeslotCreateWithoutUserInput, ProcedureTimeslotUncheckedCreateWithoutUserInput>
    where?: ProcedureTimeslotWhereInput
  }

  export type ProcedureTimeslotUpdateToOneWithWhereWithoutUserInput = {
    where?: ProcedureTimeslotWhereInput
    data: XOR<ProcedureTimeslotUpdateWithoutUserInput, ProcedureTimeslotUncheckedUpdateWithoutUserInput>
  }

  export type ProcedureTimeslotUpdateWithoutUserInput = {
    data?: JsonNullValueInput | InputJsonValue
  }

  export type ProcedureTimeslotUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    data?: JsonNullValueInput | InputJsonValue
  }

  export type InsuranceContactUpsertWithWhereUniqueWithoutUserInput = {
    where: InsuranceContactWhereUniqueInput
    update: XOR<InsuranceContactUpdateWithoutUserInput, InsuranceContactUncheckedUpdateWithoutUserInput>
    create: XOR<InsuranceContactCreateWithoutUserInput, InsuranceContactUncheckedCreateWithoutUserInput>
  }

  export type InsuranceContactUpdateWithWhereUniqueWithoutUserInput = {
    where: InsuranceContactWhereUniqueInput
    data: XOR<InsuranceContactUpdateWithoutUserInput, InsuranceContactUncheckedUpdateWithoutUserInput>
  }

  export type InsuranceContactUpdateManyWithWhereWithoutUserInput = {
    where: InsuranceContactScalarWhereInput
    data: XOR<InsuranceContactUpdateManyMutationInput, InsuranceContactUncheckedUpdateManyWithoutUserInput>
  }

  export type InsuranceContactScalarWhereInput = {
    AND?: InsuranceContactScalarWhereInput | InsuranceContactScalarWhereInput[]
    OR?: InsuranceContactScalarWhereInput[]
    NOT?: InsuranceContactScalarWhereInput | InsuranceContactScalarWhereInput[]
    id?: IntFilter<"InsuranceContact"> | number
    userId?: IntFilter<"InsuranceContact"> | number
    name?: StringFilter<"InsuranceContact"> | string
    phoneNumber?: StringNullableFilter<"InsuranceContact"> | string | null
    createdAt?: DateTimeFilter<"InsuranceContact"> | Date | string
  }

  export type PatientConversationUpsertWithWhereUniqueWithoutUserInput = {
    where: PatientConversationWhereUniqueInput
    update: XOR<PatientConversationUpdateWithoutUserInput, PatientConversationUncheckedUpdateWithoutUserInput>
    create: XOR<PatientConversationCreateWithoutUserInput, PatientConversationUncheckedCreateWithoutUserInput>
  }

  export type PatientConversationUpdateWithWhereUniqueWithoutUserInput = {
    where: PatientConversationWhereUniqueInput
    data: XOR<PatientConversationUpdateWithoutUserInput, PatientConversationUncheckedUpdateWithoutUserInput>
  }

  export type PatientConversationUpdateManyWithWhereWithoutUserInput = {
    where: PatientConversationScalarWhereInput
    data: XOR<PatientConversationUpdateManyMutationInput, PatientConversationUncheckedUpdateManyWithoutUserInput>
  }

  export type PatientConversationScalarWhereInput = {
    AND?: PatientConversationScalarWhereInput | PatientConversationScalarWhereInput[]
    OR?: PatientConversationScalarWhereInput[]
    NOT?: PatientConversationScalarWhereInput | PatientConversationScalarWhereInput[]
    id?: IntFilter<"PatientConversation"> | number
    patientId?: IntFilter<"PatientConversation"> | number
    userId?: IntFilter<"PatientConversation"> | number
    stage?: StringFilter<"PatientConversation"> | string
    aiHandoff?: BoolFilter<"PatientConversation"> | boolean
    updatedAt?: DateTimeFilter<"PatientConversation"> | Date | string
  }

  export type UserCreateWithoutPatientsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPatientsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPatientsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPatientsInput, UserUncheckedCreateWithoutPatientsInput>
  }

  export type AppointmentCreateWithoutPatientInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutPatientInput = {
    id?: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutPatientInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput>
  }

  export type AppointmentCreateManyPatientInputEnvelope = {
    data: AppointmentCreateManyPatientInput | AppointmentCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentProcedureCreateWithoutPatientInput = {
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
    appointment: AppointmentCreateNestedOneWithoutProceduresInput
    npiProvider?: NpiProviderCreateNestedOneWithoutAppointmentProceduresInput
  }

  export type AppointmentProcedureUncheckedCreateWithoutPatientInput = {
    id?: number
    appointmentId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureCreateOrConnectWithoutPatientInput = {
    where: AppointmentProcedureWhereUniqueInput
    create: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput>
  }

  export type AppointmentProcedureCreateManyPatientInputEnvelope = {
    data: AppointmentProcedureCreateManyPatientInput | AppointmentProcedureCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type ClaimCreateWithoutPatientInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutPatientInput = {
    id?: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutPatientInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput>
  }

  export type ClaimCreateManyPatientInputEnvelope = {
    data: ClaimCreateManyPatientInput | ClaimCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type PdfGroupCreateWithoutPatientInput = {
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    pdfs?: PdfFileCreateNestedManyWithoutGroupInput
  }

  export type PdfGroupUncheckedCreateWithoutPatientInput = {
    id?: number
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    pdfs?: PdfFileUncheckedCreateNestedManyWithoutGroupInput
  }

  export type PdfGroupCreateOrConnectWithoutPatientInput = {
    where: PdfGroupWhereUniqueInput
    create: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput>
  }

  export type PdfGroupCreateManyPatientInputEnvelope = {
    data: PdfGroupCreateManyPatientInput | PdfGroupCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type PaymentCreateWithoutPatientInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutPatientInput = {
    id?: number
    claimId?: number | null
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutPatientInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput>
  }

  export type PaymentCreateManyPatientInputEnvelope = {
    data: PaymentCreateManyPatientInput | PaymentCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type CommunicationCreateWithoutPatientInput = {
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
    user?: UserCreateNestedOneWithoutCommunicationsInput
  }

  export type CommunicationUncheckedCreateWithoutPatientInput = {
    id?: number
    userId?: number | null
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type CommunicationCreateOrConnectWithoutPatientInput = {
    where: CommunicationWhereUniqueInput
    create: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput>
  }

  export type CommunicationCreateManyPatientInputEnvelope = {
    data: CommunicationCreateManyPatientInput | CommunicationCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type PatientDocumentCreateWithoutPatientInput = {
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
  }

  export type PatientDocumentUncheckedCreateWithoutPatientInput = {
    id?: number
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
  }

  export type PatientDocumentCreateOrConnectWithoutPatientInput = {
    where: PatientDocumentWhereUniqueInput
    create: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput>
  }

  export type PatientDocumentCreateManyPatientInputEnvelope = {
    data: PatientDocumentCreateManyPatientInput | PatientDocumentCreateManyPatientInput[]
    skipDuplicates?: boolean
  }

  export type PatientConversationCreateWithoutPatientInput = {
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientConversationsInput
  }

  export type PatientConversationUncheckedCreateWithoutPatientInput = {
    id?: number
    userId: number
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
  }

  export type PatientConversationCreateOrConnectWithoutPatientInput = {
    where: PatientConversationWhereUniqueInput
    create: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
  }

  export type UserUpsertWithoutPatientsInput = {
    update: XOR<UserUpdateWithoutPatientsInput, UserUncheckedUpdateWithoutPatientsInput>
    create: XOR<UserCreateWithoutPatientsInput, UserUncheckedCreateWithoutPatientsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPatientsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPatientsInput, UserUncheckedUpdateWithoutPatientsInput>
  }

  export type UserUpdateWithoutPatientsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPatientsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentUpsertWithWhereUniqueWithoutPatientInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutPatientInput, AppointmentUncheckedUpdateWithoutPatientInput>
    create: XOR<AppointmentCreateWithoutPatientInput, AppointmentUncheckedCreateWithoutPatientInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutPatientInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutPatientInput, AppointmentUncheckedUpdateWithoutPatientInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutPatientInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutPatientInput>
  }

  export type AppointmentProcedureUpsertWithWhereUniqueWithoutPatientInput = {
    where: AppointmentProcedureWhereUniqueInput
    update: XOR<AppointmentProcedureUpdateWithoutPatientInput, AppointmentProcedureUncheckedUpdateWithoutPatientInput>
    create: XOR<AppointmentProcedureCreateWithoutPatientInput, AppointmentProcedureUncheckedCreateWithoutPatientInput>
  }

  export type AppointmentProcedureUpdateWithWhereUniqueWithoutPatientInput = {
    where: AppointmentProcedureWhereUniqueInput
    data: XOR<AppointmentProcedureUpdateWithoutPatientInput, AppointmentProcedureUncheckedUpdateWithoutPatientInput>
  }

  export type AppointmentProcedureUpdateManyWithWhereWithoutPatientInput = {
    where: AppointmentProcedureScalarWhereInput
    data: XOR<AppointmentProcedureUpdateManyMutationInput, AppointmentProcedureUncheckedUpdateManyWithoutPatientInput>
  }

  export type AppointmentProcedureScalarWhereInput = {
    AND?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
    OR?: AppointmentProcedureScalarWhereInput[]
    NOT?: AppointmentProcedureScalarWhereInput | AppointmentProcedureScalarWhereInput[]
    id?: IntFilter<"AppointmentProcedure"> | number
    appointmentId?: IntFilter<"AppointmentProcedure"> | number
    patientId?: IntFilter<"AppointmentProcedure"> | number
    npiProviderId?: IntNullableFilter<"AppointmentProcedure"> | number | null
    procedureCode?: StringFilter<"AppointmentProcedure"> | string
    procedureLabel?: StringNullableFilter<"AppointmentProcedure"> | string | null
    fee?: DecimalNullableFilter<"AppointmentProcedure"> | Decimal | DecimalJsLike | number | string | null
    category?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothNumber?: StringNullableFilter<"AppointmentProcedure"> | string | null
    toothSurface?: StringNullableFilter<"AppointmentProcedure"> | string | null
    oralCavityArea?: StringNullableFilter<"AppointmentProcedure"> | string | null
    source?: EnumProcedureSourceFilter<"AppointmentProcedure"> | $Enums.ProcedureSource
    comboKey?: StringNullableFilter<"AppointmentProcedure"> | string | null
    createdAt?: DateTimeFilter<"AppointmentProcedure"> | Date | string
  }

  export type ClaimUpsertWithWhereUniqueWithoutPatientInput = {
    where: ClaimWhereUniqueInput
    update: XOR<ClaimUpdateWithoutPatientInput, ClaimUncheckedUpdateWithoutPatientInput>
    create: XOR<ClaimCreateWithoutPatientInput, ClaimUncheckedCreateWithoutPatientInput>
  }

  export type ClaimUpdateWithWhereUniqueWithoutPatientInput = {
    where: ClaimWhereUniqueInput
    data: XOR<ClaimUpdateWithoutPatientInput, ClaimUncheckedUpdateWithoutPatientInput>
  }

  export type ClaimUpdateManyWithWhereWithoutPatientInput = {
    where: ClaimScalarWhereInput
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutPatientInput>
  }

  export type PdfGroupUpsertWithWhereUniqueWithoutPatientInput = {
    where: PdfGroupWhereUniqueInput
    update: XOR<PdfGroupUpdateWithoutPatientInput, PdfGroupUncheckedUpdateWithoutPatientInput>
    create: XOR<PdfGroupCreateWithoutPatientInput, PdfGroupUncheckedCreateWithoutPatientInput>
  }

  export type PdfGroupUpdateWithWhereUniqueWithoutPatientInput = {
    where: PdfGroupWhereUniqueInput
    data: XOR<PdfGroupUpdateWithoutPatientInput, PdfGroupUncheckedUpdateWithoutPatientInput>
  }

  export type PdfGroupUpdateManyWithWhereWithoutPatientInput = {
    where: PdfGroupScalarWhereInput
    data: XOR<PdfGroupUpdateManyMutationInput, PdfGroupUncheckedUpdateManyWithoutPatientInput>
  }

  export type PdfGroupScalarWhereInput = {
    AND?: PdfGroupScalarWhereInput | PdfGroupScalarWhereInput[]
    OR?: PdfGroupScalarWhereInput[]
    NOT?: PdfGroupScalarWhereInput | PdfGroupScalarWhereInput[]
    id?: IntFilter<"PdfGroup"> | number
    title?: StringFilter<"PdfGroup"> | string
    titleKey?: EnumPdfTitleKeyFilter<"PdfGroup"> | $Enums.PdfTitleKey
    createdAt?: DateTimeFilter<"PdfGroup"> | Date | string
    patientId?: IntFilter<"PdfGroup"> | number
  }

  export type PaymentUpsertWithWhereUniqueWithoutPatientInput = {
    where: PaymentWhereUniqueInput
    update: XOR<PaymentUpdateWithoutPatientInput, PaymentUncheckedUpdateWithoutPatientInput>
    create: XOR<PaymentCreateWithoutPatientInput, PaymentUncheckedCreateWithoutPatientInput>
  }

  export type PaymentUpdateWithWhereUniqueWithoutPatientInput = {
    where: PaymentWhereUniqueInput
    data: XOR<PaymentUpdateWithoutPatientInput, PaymentUncheckedUpdateWithoutPatientInput>
  }

  export type PaymentUpdateManyWithWhereWithoutPatientInput = {
    where: PaymentScalarWhereInput
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyWithoutPatientInput>
  }

  export type CommunicationUpsertWithWhereUniqueWithoutPatientInput = {
    where: CommunicationWhereUniqueInput
    update: XOR<CommunicationUpdateWithoutPatientInput, CommunicationUncheckedUpdateWithoutPatientInput>
    create: XOR<CommunicationCreateWithoutPatientInput, CommunicationUncheckedCreateWithoutPatientInput>
  }

  export type CommunicationUpdateWithWhereUniqueWithoutPatientInput = {
    where: CommunicationWhereUniqueInput
    data: XOR<CommunicationUpdateWithoutPatientInput, CommunicationUncheckedUpdateWithoutPatientInput>
  }

  export type CommunicationUpdateManyWithWhereWithoutPatientInput = {
    where: CommunicationScalarWhereInput
    data: XOR<CommunicationUpdateManyMutationInput, CommunicationUncheckedUpdateManyWithoutPatientInput>
  }

  export type PatientDocumentUpsertWithWhereUniqueWithoutPatientInput = {
    where: PatientDocumentWhereUniqueInput
    update: XOR<PatientDocumentUpdateWithoutPatientInput, PatientDocumentUncheckedUpdateWithoutPatientInput>
    create: XOR<PatientDocumentCreateWithoutPatientInput, PatientDocumentUncheckedCreateWithoutPatientInput>
  }

  export type PatientDocumentUpdateWithWhereUniqueWithoutPatientInput = {
    where: PatientDocumentWhereUniqueInput
    data: XOR<PatientDocumentUpdateWithoutPatientInput, PatientDocumentUncheckedUpdateWithoutPatientInput>
  }

  export type PatientDocumentUpdateManyWithWhereWithoutPatientInput = {
    where: PatientDocumentScalarWhereInput
    data: XOR<PatientDocumentUpdateManyMutationInput, PatientDocumentUncheckedUpdateManyWithoutPatientInput>
  }

  export type PatientDocumentScalarWhereInput = {
    AND?: PatientDocumentScalarWhereInput | PatientDocumentScalarWhereInput[]
    OR?: PatientDocumentScalarWhereInput[]
    NOT?: PatientDocumentScalarWhereInput | PatientDocumentScalarWhereInput[]
    id?: IntFilter<"PatientDocument"> | number
    patientId?: IntFilter<"PatientDocument"> | number
    filename?: StringFilter<"PatientDocument"> | string
    originalName?: StringFilter<"PatientDocument"> | string
    mimeType?: StringFilter<"PatientDocument"> | string
    fileSize?: BigIntFilter<"PatientDocument"> | bigint | number
    filePath?: StringFilter<"PatientDocument"> | string
    uploadedAt?: DateTimeFilter<"PatientDocument"> | Date | string
    updatedAt?: DateTimeFilter<"PatientDocument"> | Date | string
  }

  export type PatientConversationUpsertWithoutPatientInput = {
    update: XOR<PatientConversationUpdateWithoutPatientInput, PatientConversationUncheckedUpdateWithoutPatientInput>
    create: XOR<PatientConversationCreateWithoutPatientInput, PatientConversationUncheckedCreateWithoutPatientInput>
    where?: PatientConversationWhereInput
  }

  export type PatientConversationUpdateToOneWithWhereWithoutPatientInput = {
    where?: PatientConversationWhereInput
    data: XOR<PatientConversationUpdateWithoutPatientInput, PatientConversationUncheckedUpdateWithoutPatientInput>
  }

  export type PatientConversationUpdateWithoutPatientInput = {
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientConversationsNestedInput
  }

  export type PatientConversationUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientCreateWithoutAppointmentsInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutAppointmentsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutAppointmentsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutAppointmentsInput, PatientUncheckedCreateWithoutAppointmentsInput>
  }

  export type UserCreateWithoutAppointmentsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAppointmentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAppointmentsInput, UserUncheckedCreateWithoutAppointmentsInput>
  }

  export type StaffCreateWithoutAppointmentsInput = {
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    user?: UserCreateNestedOneWithoutStaffInput
    claims?: ClaimCreateNestedManyWithoutStaffInput
  }

  export type StaffUncheckedCreateWithoutAppointmentsInput = {
    id?: number
    userId: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutStaffInput
  }

  export type StaffCreateOrConnectWithoutAppointmentsInput = {
    where: StaffWhereUniqueInput
    create: XOR<StaffCreateWithoutAppointmentsInput, StaffUncheckedCreateWithoutAppointmentsInput>
  }

  export type AppointmentProcedureCreateWithoutAppointmentInput = {
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
    patient: PatientCreateNestedOneWithoutProceduresInput
    npiProvider?: NpiProviderCreateNestedOneWithoutAppointmentProceduresInput
  }

  export type AppointmentProcedureUncheckedCreateWithoutAppointmentInput = {
    id?: number
    patientId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureCreateOrConnectWithoutAppointmentInput = {
    where: AppointmentProcedureWhereUniqueInput
    create: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentProcedureCreateManyAppointmentInputEnvelope = {
    data: AppointmentProcedureCreateManyAppointmentInput | AppointmentProcedureCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type ClaimCreateWithoutAppointmentInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutAppointmentInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutAppointmentInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput>
  }

  export type ClaimCreateManyAppointmentInputEnvelope = {
    data: ClaimCreateManyAppointmentInput | ClaimCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentFileCreateWithoutAppointmentInput = {
    filename: string
    mimeType?: string | null
    filePath?: string | null
  }

  export type AppointmentFileUncheckedCreateWithoutAppointmentInput = {
    id?: number
    filename: string
    mimeType?: string | null
    filePath?: string | null
  }

  export type AppointmentFileCreateOrConnectWithoutAppointmentInput = {
    where: AppointmentFileWhereUniqueInput
    create: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentFileCreateManyAppointmentInputEnvelope = {
    data: AppointmentFileCreateManyAppointmentInput | AppointmentFileCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type PatientUpsertWithoutAppointmentsInput = {
    update: XOR<PatientUpdateWithoutAppointmentsInput, PatientUncheckedUpdateWithoutAppointmentsInput>
    create: XOR<PatientCreateWithoutAppointmentsInput, PatientUncheckedCreateWithoutAppointmentsInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutAppointmentsInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutAppointmentsInput, PatientUncheckedUpdateWithoutAppointmentsInput>
  }

  export type PatientUpdateWithoutAppointmentsInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutAppointmentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type UserUpsertWithoutAppointmentsInput = {
    update: XOR<UserUpdateWithoutAppointmentsInput, UserUncheckedUpdateWithoutAppointmentsInput>
    create: XOR<UserCreateWithoutAppointmentsInput, UserUncheckedCreateWithoutAppointmentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAppointmentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAppointmentsInput, UserUncheckedUpdateWithoutAppointmentsInput>
  }

  export type UserUpdateWithoutAppointmentsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type StaffUpsertWithoutAppointmentsInput = {
    update: XOR<StaffUpdateWithoutAppointmentsInput, StaffUncheckedUpdateWithoutAppointmentsInput>
    create: XOR<StaffCreateWithoutAppointmentsInput, StaffUncheckedCreateWithoutAppointmentsInput>
    where?: StaffWhereInput
  }

  export type StaffUpdateToOneWithWhereWithoutAppointmentsInput = {
    where?: StaffWhereInput
    data: XOR<StaffUpdateWithoutAppointmentsInput, StaffUncheckedUpdateWithoutAppointmentsInput>
  }

  export type StaffUpdateWithoutAppointmentsInput = {
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutStaffNestedInput
    claims?: ClaimUpdateManyWithoutStaffNestedInput
  }

  export type StaffUncheckedUpdateWithoutAppointmentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutStaffNestedInput
  }

  export type AppointmentProcedureUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentProcedureWhereUniqueInput
    update: XOR<AppointmentProcedureUpdateWithoutAppointmentInput, AppointmentProcedureUncheckedUpdateWithoutAppointmentInput>
    create: XOR<AppointmentProcedureCreateWithoutAppointmentInput, AppointmentProcedureUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentProcedureUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentProcedureWhereUniqueInput
    data: XOR<AppointmentProcedureUpdateWithoutAppointmentInput, AppointmentProcedureUncheckedUpdateWithoutAppointmentInput>
  }

  export type AppointmentProcedureUpdateManyWithWhereWithoutAppointmentInput = {
    where: AppointmentProcedureScalarWhereInput
    data: XOR<AppointmentProcedureUpdateManyMutationInput, AppointmentProcedureUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type ClaimUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: ClaimWhereUniqueInput
    update: XOR<ClaimUpdateWithoutAppointmentInput, ClaimUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ClaimCreateWithoutAppointmentInput, ClaimUncheckedCreateWithoutAppointmentInput>
  }

  export type ClaimUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: ClaimWhereUniqueInput
    data: XOR<ClaimUpdateWithoutAppointmentInput, ClaimUncheckedUpdateWithoutAppointmentInput>
  }

  export type ClaimUpdateManyWithWhereWithoutAppointmentInput = {
    where: ClaimScalarWhereInput
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type AppointmentFileUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentFileWhereUniqueInput
    update: XOR<AppointmentFileUpdateWithoutAppointmentInput, AppointmentFileUncheckedUpdateWithoutAppointmentInput>
    create: XOR<AppointmentFileCreateWithoutAppointmentInput, AppointmentFileUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentFileUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentFileWhereUniqueInput
    data: XOR<AppointmentFileUpdateWithoutAppointmentInput, AppointmentFileUncheckedUpdateWithoutAppointmentInput>
  }

  export type AppointmentFileUpdateManyWithWhereWithoutAppointmentInput = {
    where: AppointmentFileScalarWhereInput
    data: XOR<AppointmentFileUpdateManyMutationInput, AppointmentFileUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type AppointmentFileScalarWhereInput = {
    AND?: AppointmentFileScalarWhereInput | AppointmentFileScalarWhereInput[]
    OR?: AppointmentFileScalarWhereInput[]
    NOT?: AppointmentFileScalarWhereInput | AppointmentFileScalarWhereInput[]
    id?: IntFilter<"AppointmentFile"> | number
    appointmentId?: IntFilter<"AppointmentFile"> | number
    filename?: StringFilter<"AppointmentFile"> | string
    mimeType?: StringNullableFilter<"AppointmentFile"> | string | null
    filePath?: StringNullableFilter<"AppointmentFile"> | string | null
  }

  export type AppointmentCreateWithoutFilesInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutFilesInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutFilesInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutFilesInput, AppointmentUncheckedCreateWithoutFilesInput>
  }

  export type AppointmentUpsertWithoutFilesInput = {
    update: XOR<AppointmentUpdateWithoutFilesInput, AppointmentUncheckedUpdateWithoutFilesInput>
    create: XOR<AppointmentCreateWithoutFilesInput, AppointmentUncheckedCreateWithoutFilesInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutFilesInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutFilesInput, AppointmentUncheckedUpdateWithoutFilesInput>
  }

  export type AppointmentUpdateWithoutFilesInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserCreateWithoutStaffInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutStaffInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutStaffInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutStaffInput, UserUncheckedCreateWithoutStaffInput>
  }

  export type AppointmentCreateWithoutStaffInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutStaffInput = {
    id?: number
    patientId: number
    userId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutStaffInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput>
  }

  export type AppointmentCreateManyStaffInputEnvelope = {
    data: AppointmentCreateManyStaffInput | AppointmentCreateManyStaffInput[]
    skipDuplicates?: boolean
  }

  export type ClaimCreateWithoutStaffInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutStaffInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutStaffInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput>
  }

  export type ClaimCreateManyStaffInputEnvelope = {
    data: ClaimCreateManyStaffInput | ClaimCreateManyStaffInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutStaffInput = {
    update: XOR<UserUpdateWithoutStaffInput, UserUncheckedUpdateWithoutStaffInput>
    create: XOR<UserCreateWithoutStaffInput, UserUncheckedCreateWithoutStaffInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutStaffInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutStaffInput, UserUncheckedUpdateWithoutStaffInput>
  }

  export type UserUpdateWithoutStaffInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentUpsertWithWhereUniqueWithoutStaffInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutStaffInput, AppointmentUncheckedUpdateWithoutStaffInput>
    create: XOR<AppointmentCreateWithoutStaffInput, AppointmentUncheckedCreateWithoutStaffInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutStaffInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutStaffInput, AppointmentUncheckedUpdateWithoutStaffInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutStaffInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutStaffInput>
  }

  export type ClaimUpsertWithWhereUniqueWithoutStaffInput = {
    where: ClaimWhereUniqueInput
    update: XOR<ClaimUpdateWithoutStaffInput, ClaimUncheckedUpdateWithoutStaffInput>
    create: XOR<ClaimCreateWithoutStaffInput, ClaimUncheckedCreateWithoutStaffInput>
  }

  export type ClaimUpdateWithWhereUniqueWithoutStaffInput = {
    where: ClaimWhereUniqueInput
    data: XOR<ClaimUpdateWithoutStaffInput, ClaimUncheckedUpdateWithoutStaffInput>
  }

  export type ClaimUpdateManyWithWhereWithoutStaffInput = {
    where: ClaimScalarWhereInput
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutStaffInput>
  }

  export type UserCreateWithoutNpiProvidersInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutNpiProvidersInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutNpiProvidersInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
  }

  export type ClaimCreateWithoutNpiProviderInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutNpiProviderInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutNpiProviderInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput>
  }

  export type ClaimCreateManyNpiProviderInputEnvelope = {
    data: ClaimCreateManyNpiProviderInput | ClaimCreateManyNpiProviderInput[]
    skipDuplicates?: boolean
  }

  export type PaymentCreateWithoutNpiProviderInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutNpiProviderInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutNpiProviderInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput>
  }

  export type PaymentCreateManyNpiProviderInputEnvelope = {
    data: PaymentCreateManyNpiProviderInput | PaymentCreateManyNpiProviderInput[]
    skipDuplicates?: boolean
  }

  export type CommissionBatchCreateWithoutNpiProviderInput = {
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
    items?: CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput
  }

  export type CommissionBatchUncheckedCreateWithoutNpiProviderInput = {
    id?: number
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
    items?: CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput
  }

  export type CommissionBatchCreateOrConnectWithoutNpiProviderInput = {
    where: CommissionBatchWhereUniqueInput
    create: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput>
  }

  export type CommissionBatchCreateManyNpiProviderInputEnvelope = {
    data: CommissionBatchCreateManyNpiProviderInput | CommissionBatchCreateManyNpiProviderInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentProcedureCreateWithoutNpiProviderInput = {
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
    appointment: AppointmentCreateNestedOneWithoutProceduresInput
    patient: PatientCreateNestedOneWithoutProceduresInput
  }

  export type AppointmentProcedureUncheckedCreateWithoutNpiProviderInput = {
    id?: number
    appointmentId: number
    patientId: number
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureCreateOrConnectWithoutNpiProviderInput = {
    where: AppointmentProcedureWhereUniqueInput
    create: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput>
  }

  export type AppointmentProcedureCreateManyNpiProviderInputEnvelope = {
    data: AppointmentProcedureCreateManyNpiProviderInput | AppointmentProcedureCreateManyNpiProviderInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutNpiProvidersInput = {
    update: XOR<UserUpdateWithoutNpiProvidersInput, UserUncheckedUpdateWithoutNpiProvidersInput>
    create: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutNpiProvidersInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutNpiProvidersInput, UserUncheckedUpdateWithoutNpiProvidersInput>
  }

  export type UserUpdateWithoutNpiProvidersInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutNpiProvidersInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ClaimUpsertWithWhereUniqueWithoutNpiProviderInput = {
    where: ClaimWhereUniqueInput
    update: XOR<ClaimUpdateWithoutNpiProviderInput, ClaimUncheckedUpdateWithoutNpiProviderInput>
    create: XOR<ClaimCreateWithoutNpiProviderInput, ClaimUncheckedCreateWithoutNpiProviderInput>
  }

  export type ClaimUpdateWithWhereUniqueWithoutNpiProviderInput = {
    where: ClaimWhereUniqueInput
    data: XOR<ClaimUpdateWithoutNpiProviderInput, ClaimUncheckedUpdateWithoutNpiProviderInput>
  }

  export type ClaimUpdateManyWithWhereWithoutNpiProviderInput = {
    where: ClaimScalarWhereInput
    data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutNpiProviderInput>
  }

  export type PaymentUpsertWithWhereUniqueWithoutNpiProviderInput = {
    where: PaymentWhereUniqueInput
    update: XOR<PaymentUpdateWithoutNpiProviderInput, PaymentUncheckedUpdateWithoutNpiProviderInput>
    create: XOR<PaymentCreateWithoutNpiProviderInput, PaymentUncheckedCreateWithoutNpiProviderInput>
  }

  export type PaymentUpdateWithWhereUniqueWithoutNpiProviderInput = {
    where: PaymentWhereUniqueInput
    data: XOR<PaymentUpdateWithoutNpiProviderInput, PaymentUncheckedUpdateWithoutNpiProviderInput>
  }

  export type PaymentUpdateManyWithWhereWithoutNpiProviderInput = {
    where: PaymentScalarWhereInput
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyWithoutNpiProviderInput>
  }

  export type CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput = {
    where: CommissionBatchWhereUniqueInput
    update: XOR<CommissionBatchUpdateWithoutNpiProviderInput, CommissionBatchUncheckedUpdateWithoutNpiProviderInput>
    create: XOR<CommissionBatchCreateWithoutNpiProviderInput, CommissionBatchUncheckedCreateWithoutNpiProviderInput>
  }

  export type CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput = {
    where: CommissionBatchWhereUniqueInput
    data: XOR<CommissionBatchUpdateWithoutNpiProviderInput, CommissionBatchUncheckedUpdateWithoutNpiProviderInput>
  }

  export type CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput = {
    where: CommissionBatchScalarWhereInput
    data: XOR<CommissionBatchUpdateManyMutationInput, CommissionBatchUncheckedUpdateManyWithoutNpiProviderInput>
  }

  export type CommissionBatchScalarWhereInput = {
    AND?: CommissionBatchScalarWhereInput | CommissionBatchScalarWhereInput[]
    OR?: CommissionBatchScalarWhereInput[]
    NOT?: CommissionBatchScalarWhereInput | CommissionBatchScalarWhereInput[]
    id?: IntFilter<"CommissionBatch"> | number
    npiProviderId?: IntFilter<"CommissionBatch"> | number
    totalCollection?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFilter<"CommissionBatch"> | Decimal | DecimalJsLike | number | string
    notes?: StringNullableFilter<"CommissionBatch"> | string | null
    createdAt?: DateTimeFilter<"CommissionBatch"> | Date | string
  }

  export type AppointmentProcedureUpsertWithWhereUniqueWithoutNpiProviderInput = {
    where: AppointmentProcedureWhereUniqueInput
    update: XOR<AppointmentProcedureUpdateWithoutNpiProviderInput, AppointmentProcedureUncheckedUpdateWithoutNpiProviderInput>
    create: XOR<AppointmentProcedureCreateWithoutNpiProviderInput, AppointmentProcedureUncheckedCreateWithoutNpiProviderInput>
  }

  export type AppointmentProcedureUpdateWithWhereUniqueWithoutNpiProviderInput = {
    where: AppointmentProcedureWhereUniqueInput
    data: XOR<AppointmentProcedureUpdateWithoutNpiProviderInput, AppointmentProcedureUncheckedUpdateWithoutNpiProviderInput>
  }

  export type AppointmentProcedureUpdateManyWithWhereWithoutNpiProviderInput = {
    where: AppointmentProcedureScalarWhereInput
    data: XOR<AppointmentProcedureUpdateManyMutationInput, AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderInput>
  }

  export type AppointmentCreateWithoutProceduresInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutProceduresInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutProceduresInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
  }

  export type PatientCreateWithoutProceduresInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutProceduresInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutProceduresInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
  }

  export type NpiProviderCreateWithoutAppointmentProceduresInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutNpiProvidersInput
    claims?: ClaimCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateWithoutAppointmentProceduresInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentUncheckedCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderCreateOrConnectWithoutAppointmentProceduresInput = {
    where: NpiProviderWhereUniqueInput
    create: XOR<NpiProviderCreateWithoutAppointmentProceduresInput, NpiProviderUncheckedCreateWithoutAppointmentProceduresInput>
  }

  export type AppointmentUpsertWithoutProceduresInput = {
    update: XOR<AppointmentUpdateWithoutProceduresInput, AppointmentUncheckedUpdateWithoutProceduresInput>
    create: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutProceduresInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutProceduresInput, AppointmentUncheckedUpdateWithoutProceduresInput>
  }

  export type AppointmentUpdateWithoutProceduresInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutProceduresInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type PatientUpsertWithoutProceduresInput = {
    update: XOR<PatientUpdateWithoutProceduresInput, PatientUncheckedUpdateWithoutProceduresInput>
    create: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutProceduresInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutProceduresInput, PatientUncheckedUpdateWithoutProceduresInput>
  }

  export type PatientUpdateWithoutProceduresInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutProceduresInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type NpiProviderUpsertWithoutAppointmentProceduresInput = {
    update: XOR<NpiProviderUpdateWithoutAppointmentProceduresInput, NpiProviderUncheckedUpdateWithoutAppointmentProceduresInput>
    create: XOR<NpiProviderCreateWithoutAppointmentProceduresInput, NpiProviderUncheckedCreateWithoutAppointmentProceduresInput>
    where?: NpiProviderWhereInput
  }

  export type NpiProviderUpdateToOneWithWhereWithoutAppointmentProceduresInput = {
    where?: NpiProviderWhereInput
    data: XOR<NpiProviderUpdateWithoutAppointmentProceduresInput, NpiProviderUncheckedUpdateWithoutAppointmentProceduresInput>
  }

  export type NpiProviderUpdateWithoutAppointmentProceduresInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
    claims?: ClaimUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateWithoutAppointmentProceduresInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type PatientCreateWithoutClaimsInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutClaimsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutClaimsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutClaimsInput, PatientUncheckedCreateWithoutClaimsInput>
  }

  export type AppointmentCreateWithoutClaimsInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutClaimsInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    files?: AppointmentFileUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutClaimsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
  }

  export type UserCreateWithoutClaimsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutClaimsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutClaimsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutClaimsInput, UserUncheckedCreateWithoutClaimsInput>
  }

  export type StaffCreateWithoutClaimsInput = {
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    user?: UserCreateNestedOneWithoutStaffInput
    appointments?: AppointmentCreateNestedManyWithoutStaffInput
  }

  export type StaffUncheckedCreateWithoutClaimsInput = {
    id?: number
    userId: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutStaffInput
  }

  export type StaffCreateOrConnectWithoutClaimsInput = {
    where: StaffWhereUniqueInput
    create: XOR<StaffCreateWithoutClaimsInput, StaffUncheckedCreateWithoutClaimsInput>
  }

  export type NpiProviderCreateWithoutClaimsInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutNpiProvidersInput
    payments?: PaymentCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateWithoutClaimsInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    payments?: PaymentUncheckedCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderCreateOrConnectWithoutClaimsInput = {
    where: NpiProviderWhereUniqueInput
    create: XOR<NpiProviderCreateWithoutClaimsInput, NpiProviderUncheckedCreateWithoutClaimsInput>
  }

  export type ServiceLineCreateWithoutClaimInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    payment?: PaymentCreateNestedOneWithoutServiceLinesInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineUncheckedCreateWithoutClaimInput = {
    id?: number
    paymentId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineCreateOrConnectWithoutClaimInput = {
    where: ServiceLineWhereUniqueInput
    create: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput>
  }

  export type ServiceLineCreateManyClaimInputEnvelope = {
    data: ServiceLineCreateManyClaimInput | ServiceLineCreateManyClaimInput[]
    skipDuplicates?: boolean
  }

  export type ClaimFileCreateWithoutClaimInput = {
    filename: string
    mimeType: string
    filePath?: string | null
  }

  export type ClaimFileUncheckedCreateWithoutClaimInput = {
    id?: number
    filename: string
    mimeType: string
    filePath?: string | null
  }

  export type ClaimFileCreateOrConnectWithoutClaimInput = {
    where: ClaimFileWhereUniqueInput
    create: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput>
  }

  export type ClaimFileCreateManyClaimInputEnvelope = {
    data: ClaimFileCreateManyClaimInput | ClaimFileCreateManyClaimInput[]
    skipDuplicates?: boolean
  }

  export type PaymentCreateWithoutClaimInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutClaimInput = {
    id?: number
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutClaimInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
  }

  export type PatientUpsertWithoutClaimsInput = {
    update: XOR<PatientUpdateWithoutClaimsInput, PatientUncheckedUpdateWithoutClaimsInput>
    create: XOR<PatientCreateWithoutClaimsInput, PatientUncheckedCreateWithoutClaimsInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutClaimsInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutClaimsInput, PatientUncheckedUpdateWithoutClaimsInput>
  }

  export type PatientUpdateWithoutClaimsInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type AppointmentUpsertWithoutClaimsInput = {
    update: XOR<AppointmentUpdateWithoutClaimsInput, AppointmentUncheckedUpdateWithoutClaimsInput>
    create: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutClaimsInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutClaimsInput, AppointmentUncheckedUpdateWithoutClaimsInput>
  }

  export type AppointmentUpdateWithoutClaimsInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserUpsertWithoutClaimsInput = {
    update: XOR<UserUpdateWithoutClaimsInput, UserUncheckedUpdateWithoutClaimsInput>
    create: XOR<UserCreateWithoutClaimsInput, UserUncheckedCreateWithoutClaimsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutClaimsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutClaimsInput, UserUncheckedUpdateWithoutClaimsInput>
  }

  export type UserUpdateWithoutClaimsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type StaffUpsertWithoutClaimsInput = {
    update: XOR<StaffUpdateWithoutClaimsInput, StaffUncheckedUpdateWithoutClaimsInput>
    create: XOR<StaffCreateWithoutClaimsInput, StaffUncheckedCreateWithoutClaimsInput>
    where?: StaffWhereInput
  }

  export type StaffUpdateToOneWithWhereWithoutClaimsInput = {
    where?: StaffWhereInput
    data: XOR<StaffUpdateWithoutClaimsInput, StaffUncheckedUpdateWithoutClaimsInput>
  }

  export type StaffUpdateWithoutClaimsInput = {
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutStaffNestedInput
    appointments?: AppointmentUpdateManyWithoutStaffNestedInput
  }

  export type StaffUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutStaffNestedInput
  }

  export type NpiProviderUpsertWithoutClaimsInput = {
    update: XOR<NpiProviderUpdateWithoutClaimsInput, NpiProviderUncheckedUpdateWithoutClaimsInput>
    create: XOR<NpiProviderCreateWithoutClaimsInput, NpiProviderUncheckedCreateWithoutClaimsInput>
    where?: NpiProviderWhereInput
  }

  export type NpiProviderUpdateToOneWithWhereWithoutClaimsInput = {
    where?: NpiProviderWhereInput
    data: XOR<NpiProviderUpdateWithoutClaimsInput, NpiProviderUncheckedUpdateWithoutClaimsInput>
  }

  export type NpiProviderUpdateWithoutClaimsInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
    payments?: PaymentUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payments?: PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type ServiceLineUpsertWithWhereUniqueWithoutClaimInput = {
    where: ServiceLineWhereUniqueInput
    update: XOR<ServiceLineUpdateWithoutClaimInput, ServiceLineUncheckedUpdateWithoutClaimInput>
    create: XOR<ServiceLineCreateWithoutClaimInput, ServiceLineUncheckedCreateWithoutClaimInput>
  }

  export type ServiceLineUpdateWithWhereUniqueWithoutClaimInput = {
    where: ServiceLineWhereUniqueInput
    data: XOR<ServiceLineUpdateWithoutClaimInput, ServiceLineUncheckedUpdateWithoutClaimInput>
  }

  export type ServiceLineUpdateManyWithWhereWithoutClaimInput = {
    where: ServiceLineScalarWhereInput
    data: XOR<ServiceLineUpdateManyMutationInput, ServiceLineUncheckedUpdateManyWithoutClaimInput>
  }

  export type ServiceLineScalarWhereInput = {
    AND?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
    OR?: ServiceLineScalarWhereInput[]
    NOT?: ServiceLineScalarWhereInput | ServiceLineScalarWhereInput[]
    id?: IntFilter<"ServiceLine"> | number
    claimId?: IntNullableFilter<"ServiceLine"> | number | null
    paymentId?: IntNullableFilter<"ServiceLine"> | number | null
    procedureCode?: StringFilter<"ServiceLine"> | string
    procedureDate?: DateTimeFilter<"ServiceLine"> | Date | string
    quad?: StringNullableFilter<"ServiceLine"> | string | null
    arch?: StringNullableFilter<"ServiceLine"> | string | null
    toothNumber?: StringNullableFilter<"ServiceLine"> | string | null
    toothSurface?: StringNullableFilter<"ServiceLine"> | string | null
    icn?: StringNullableFilter<"ServiceLine"> | string | null
    paidCode?: StringNullableFilter<"ServiceLine"> | string | null
    allowedAmount?: DecimalNullableFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFilter<"ServiceLine"> | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFilter<"ServiceLine"> | $Enums.ServiceLineStatus
  }

  export type ClaimFileUpsertWithWhereUniqueWithoutClaimInput = {
    where: ClaimFileWhereUniqueInput
    update: XOR<ClaimFileUpdateWithoutClaimInput, ClaimFileUncheckedUpdateWithoutClaimInput>
    create: XOR<ClaimFileCreateWithoutClaimInput, ClaimFileUncheckedCreateWithoutClaimInput>
  }

  export type ClaimFileUpdateWithWhereUniqueWithoutClaimInput = {
    where: ClaimFileWhereUniqueInput
    data: XOR<ClaimFileUpdateWithoutClaimInput, ClaimFileUncheckedUpdateWithoutClaimInput>
  }

  export type ClaimFileUpdateManyWithWhereWithoutClaimInput = {
    where: ClaimFileScalarWhereInput
    data: XOR<ClaimFileUpdateManyMutationInput, ClaimFileUncheckedUpdateManyWithoutClaimInput>
  }

  export type ClaimFileScalarWhereInput = {
    AND?: ClaimFileScalarWhereInput | ClaimFileScalarWhereInput[]
    OR?: ClaimFileScalarWhereInput[]
    NOT?: ClaimFileScalarWhereInput | ClaimFileScalarWhereInput[]
    id?: IntFilter<"ClaimFile"> | number
    claimId?: IntFilter<"ClaimFile"> | number
    filename?: StringFilter<"ClaimFile"> | string
    mimeType?: StringFilter<"ClaimFile"> | string
    filePath?: StringNullableFilter<"ClaimFile"> | string | null
  }

  export type PaymentUpsertWithoutClaimInput = {
    update: XOR<PaymentUpdateWithoutClaimInput, PaymentUncheckedUpdateWithoutClaimInput>
    create: XOR<PaymentCreateWithoutClaimInput, PaymentUncheckedCreateWithoutClaimInput>
    where?: PaymentWhereInput
  }

  export type PaymentUpdateToOneWithWhereWithoutClaimInput = {
    where?: PaymentWhereInput
    data: XOR<PaymentUpdateWithoutClaimInput, PaymentUncheckedUpdateWithoutClaimInput>
  }

  export type PaymentUpdateWithoutClaimInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type ClaimCreateWithoutServiceLinesInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutServiceLinesInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutServiceLinesInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutServiceLinesInput, ClaimUncheckedCreateWithoutServiceLinesInput>
  }

  export type PaymentCreateWithoutServiceLinesInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutServiceLinesInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutServiceLinesInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutServiceLinesInput, PaymentUncheckedCreateWithoutServiceLinesInput>
  }

  export type ServiceLineTransactionCreateWithoutServiceLineInput = {
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
    payment: PaymentCreateNestedOneWithoutServiceLineTransactionsInput
  }

  export type ServiceLineTransactionUncheckedCreateWithoutServiceLineInput = {
    id?: number
    paymentId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineTransactionCreateOrConnectWithoutServiceLineInput = {
    where: ServiceLineTransactionWhereUniqueInput
    create: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput>
  }

  export type ServiceLineTransactionCreateManyServiceLineInputEnvelope = {
    data: ServiceLineTransactionCreateManyServiceLineInput | ServiceLineTransactionCreateManyServiceLineInput[]
    skipDuplicates?: boolean
  }

  export type ClaimUpsertWithoutServiceLinesInput = {
    update: XOR<ClaimUpdateWithoutServiceLinesInput, ClaimUncheckedUpdateWithoutServiceLinesInput>
    create: XOR<ClaimCreateWithoutServiceLinesInput, ClaimUncheckedCreateWithoutServiceLinesInput>
    where?: ClaimWhereInput
  }

  export type ClaimUpdateToOneWithWhereWithoutServiceLinesInput = {
    where?: ClaimWhereInput
    data: XOR<ClaimUpdateWithoutServiceLinesInput, ClaimUncheckedUpdateWithoutServiceLinesInput>
  }

  export type ClaimUpdateWithoutServiceLinesInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutServiceLinesInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type PaymentUpsertWithoutServiceLinesInput = {
    update: XOR<PaymentUpdateWithoutServiceLinesInput, PaymentUncheckedUpdateWithoutServiceLinesInput>
    create: XOR<PaymentCreateWithoutServiceLinesInput, PaymentUncheckedCreateWithoutServiceLinesInput>
    where?: PaymentWhereInput
  }

  export type PaymentUpdateToOneWithWhereWithoutServiceLinesInput = {
    where?: PaymentWhereInput
    data: XOR<PaymentUpdateWithoutServiceLinesInput, PaymentUncheckedUpdateWithoutServiceLinesInput>
  }

  export type PaymentUpdateWithoutServiceLinesInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutServiceLinesInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type ServiceLineTransactionUpsertWithWhereUniqueWithoutServiceLineInput = {
    where: ServiceLineTransactionWhereUniqueInput
    update: XOR<ServiceLineTransactionUpdateWithoutServiceLineInput, ServiceLineTransactionUncheckedUpdateWithoutServiceLineInput>
    create: XOR<ServiceLineTransactionCreateWithoutServiceLineInput, ServiceLineTransactionUncheckedCreateWithoutServiceLineInput>
  }

  export type ServiceLineTransactionUpdateWithWhereUniqueWithoutServiceLineInput = {
    where: ServiceLineTransactionWhereUniqueInput
    data: XOR<ServiceLineTransactionUpdateWithoutServiceLineInput, ServiceLineTransactionUncheckedUpdateWithoutServiceLineInput>
  }

  export type ServiceLineTransactionUpdateManyWithWhereWithoutServiceLineInput = {
    where: ServiceLineTransactionScalarWhereInput
    data: XOR<ServiceLineTransactionUpdateManyMutationInput, ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineInput>
  }

  export type ServiceLineTransactionScalarWhereInput = {
    AND?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
    OR?: ServiceLineTransactionScalarWhereInput[]
    NOT?: ServiceLineTransactionScalarWhereInput | ServiceLineTransactionScalarWhereInput[]
    id?: IntFilter<"ServiceLineTransaction"> | number
    paymentId?: IntFilter<"ServiceLineTransaction"> | number
    serviceLineId?: IntFilter<"ServiceLineTransaction"> | number
    transactionId?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    paidAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFilter<"ServiceLineTransaction"> | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFilter<"ServiceLineTransaction"> | $Enums.PaymentMethod
    receivedDate?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
    payerName?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    notes?: StringNullableFilter<"ServiceLineTransaction"> | string | null
    createdAt?: DateTimeFilter<"ServiceLineTransaction"> | Date | string
  }

  export type ClaimCreateWithoutClaimFilesInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutClaimFilesInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    payment?: PaymentUncheckedCreateNestedOneWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutClaimFilesInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutClaimFilesInput, ClaimUncheckedCreateWithoutClaimFilesInput>
  }

  export type ClaimUpsertWithoutClaimFilesInput = {
    update: XOR<ClaimUpdateWithoutClaimFilesInput, ClaimUncheckedUpdateWithoutClaimFilesInput>
    create: XOR<ClaimCreateWithoutClaimFilesInput, ClaimUncheckedCreateWithoutClaimFilesInput>
    where?: ClaimWhereInput
  }

  export type ClaimUpdateToOneWithWhereWithoutClaimFilesInput = {
    where?: ClaimWhereInput
    data: XOR<ClaimUpdateWithoutClaimFilesInput, ClaimUncheckedUpdateWithoutClaimFilesInput>
  }

  export type ClaimUpdateWithoutClaimFilesInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutClaimFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type UserCreateWithoutInsuranceCredentialsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutInsuranceCredentialsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutInsuranceCredentialsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutInsuranceCredentialsInput, UserUncheckedCreateWithoutInsuranceCredentialsInput>
  }

  export type UserUpsertWithoutInsuranceCredentialsInput = {
    update: XOR<UserUpdateWithoutInsuranceCredentialsInput, UserUncheckedUpdateWithoutInsuranceCredentialsInput>
    create: XOR<UserCreateWithoutInsuranceCredentialsInput, UserUncheckedCreateWithoutInsuranceCredentialsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutInsuranceCredentialsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutInsuranceCredentialsInput, UserUncheckedUpdateWithoutInsuranceCredentialsInput>
  }

  export type UserUpdateWithoutInsuranceCredentialsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutInsuranceCredentialsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutShoppingVendorsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutShoppingVendorsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutShoppingVendorsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutShoppingVendorsInput, UserUncheckedCreateWithoutShoppingVendorsInput>
  }

  export type UserUpsertWithoutShoppingVendorsInput = {
    update: XOR<UserUpdateWithoutShoppingVendorsInput, UserUncheckedUpdateWithoutShoppingVendorsInput>
    create: XOR<UserCreateWithoutShoppingVendorsInput, UserUncheckedCreateWithoutShoppingVendorsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutShoppingVendorsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutShoppingVendorsInput, UserUncheckedUpdateWithoutShoppingVendorsInput>
  }

  export type UserUpdateWithoutShoppingVendorsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutShoppingVendorsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PatientCreateWithoutGroupsInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutGroupsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutGroupsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutGroupsInput, PatientUncheckedCreateWithoutGroupsInput>
  }

  export type PdfFileCreateWithoutGroupInput = {
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
  }

  export type PdfFileUncheckedCreateWithoutGroupInput = {
    id?: number
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
  }

  export type PdfFileCreateOrConnectWithoutGroupInput = {
    where: PdfFileWhereUniqueInput
    create: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput>
  }

  export type PdfFileCreateManyGroupInputEnvelope = {
    data: PdfFileCreateManyGroupInput | PdfFileCreateManyGroupInput[]
    skipDuplicates?: boolean
  }

  export type PatientUpsertWithoutGroupsInput = {
    update: XOR<PatientUpdateWithoutGroupsInput, PatientUncheckedUpdateWithoutGroupsInput>
    create: XOR<PatientCreateWithoutGroupsInput, PatientUncheckedCreateWithoutGroupsInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutGroupsInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutGroupsInput, PatientUncheckedUpdateWithoutGroupsInput>
  }

  export type PatientUpdateWithoutGroupsInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutGroupsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type PdfFileUpsertWithWhereUniqueWithoutGroupInput = {
    where: PdfFileWhereUniqueInput
    update: XOR<PdfFileUpdateWithoutGroupInput, PdfFileUncheckedUpdateWithoutGroupInput>
    create: XOR<PdfFileCreateWithoutGroupInput, PdfFileUncheckedCreateWithoutGroupInput>
  }

  export type PdfFileUpdateWithWhereUniqueWithoutGroupInput = {
    where: PdfFileWhereUniqueInput
    data: XOR<PdfFileUpdateWithoutGroupInput, PdfFileUncheckedUpdateWithoutGroupInput>
  }

  export type PdfFileUpdateManyWithWhereWithoutGroupInput = {
    where: PdfFileScalarWhereInput
    data: XOR<PdfFileUpdateManyMutationInput, PdfFileUncheckedUpdateManyWithoutGroupInput>
  }

  export type PdfFileScalarWhereInput = {
    AND?: PdfFileScalarWhereInput | PdfFileScalarWhereInput[]
    OR?: PdfFileScalarWhereInput[]
    NOT?: PdfFileScalarWhereInput | PdfFileScalarWhereInput[]
    id?: IntFilter<"PdfFile"> | number
    filename?: StringFilter<"PdfFile"> | string
    pdfData?: BytesFilter<"PdfFile"> | Bytes
    uploadedAt?: DateTimeFilter<"PdfFile"> | Date | string
    groupId?: IntFilter<"PdfFile"> | number
  }

  export type PdfGroupCreateWithoutPdfsInput = {
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    patient: PatientCreateNestedOneWithoutGroupsInput
  }

  export type PdfGroupUncheckedCreateWithoutPdfsInput = {
    id?: number
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
    patientId: number
  }

  export type PdfGroupCreateOrConnectWithoutPdfsInput = {
    where: PdfGroupWhereUniqueInput
    create: XOR<PdfGroupCreateWithoutPdfsInput, PdfGroupUncheckedCreateWithoutPdfsInput>
  }

  export type PdfGroupUpsertWithoutPdfsInput = {
    update: XOR<PdfGroupUpdateWithoutPdfsInput, PdfGroupUncheckedUpdateWithoutPdfsInput>
    create: XOR<PdfGroupCreateWithoutPdfsInput, PdfGroupUncheckedCreateWithoutPdfsInput>
    where?: PdfGroupWhereInput
  }

  export type PdfGroupUpdateToOneWithWhereWithoutPdfsInput = {
    where?: PdfGroupWhereInput
    data: XOR<PdfGroupUpdateWithoutPdfsInput, PdfGroupUncheckedUpdateWithoutPdfsInput>
  }

  export type PdfGroupUpdateWithoutPdfsInput = {
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutGroupsNestedInput
  }

  export type PdfGroupUncheckedUpdateWithoutPdfsInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patientId?: IntFieldUpdateOperationsInput | number
  }

  export type ClaimCreateWithoutPaymentInput = {
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment?: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutPaymentInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutPaymentInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutPaymentInput, ClaimUncheckedCreateWithoutPaymentInput>
  }

  export type PatientCreateWithoutPaymentInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutPaymentInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutPaymentInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutPaymentInput, PatientUncheckedCreateWithoutPaymentInput>
  }

  export type UserCreateWithoutUpdatedPaymentsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutUpdatedPaymentsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutUpdatedPaymentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutUpdatedPaymentsInput, UserUncheckedCreateWithoutUpdatedPaymentsInput>
  }

  export type NpiProviderCreateWithoutPaymentsInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutNpiProvidersInput
    claims?: ClaimCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateWithoutPaymentsInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutNpiProviderInput
    commissionBatches?: CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderCreateOrConnectWithoutPaymentsInput = {
    where: NpiProviderWhereUniqueInput
    create: XOR<NpiProviderCreateWithoutPaymentsInput, NpiProviderUncheckedCreateWithoutPaymentsInput>
  }

  export type ServiceLineTransactionCreateWithoutPaymentInput = {
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
    serviceLine: ServiceLineCreateNestedOneWithoutServiceLineTransactionsInput
  }

  export type ServiceLineTransactionUncheckedCreateWithoutPaymentInput = {
    id?: number
    serviceLineId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineTransactionCreateOrConnectWithoutPaymentInput = {
    where: ServiceLineTransactionWhereUniqueInput
    create: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput>
  }

  export type ServiceLineTransactionCreateManyPaymentInputEnvelope = {
    data: ServiceLineTransactionCreateManyPaymentInput | ServiceLineTransactionCreateManyPaymentInput[]
    skipDuplicates?: boolean
  }

  export type ServiceLineCreateWithoutPaymentInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    claim?: ClaimCreateNestedOneWithoutServiceLinesInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineUncheckedCreateWithoutPaymentInput = {
    id?: number
    claimId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutServiceLineInput
  }

  export type ServiceLineCreateOrConnectWithoutPaymentInput = {
    where: ServiceLineWhereUniqueInput
    create: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput>
  }

  export type ServiceLineCreateManyPaymentInputEnvelope = {
    data: ServiceLineCreateManyPaymentInput | ServiceLineCreateManyPaymentInput[]
    skipDuplicates?: boolean
  }

  export type CommissionBatchItemCreateWithoutPaymentInput = {
    collectionAmount: Decimal | DecimalJsLike | number | string
    commissionBatch: CommissionBatchCreateNestedOneWithoutItemsInput
  }

  export type CommissionBatchItemUncheckedCreateWithoutPaymentInput = {
    id?: number
    commissionBatchId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemCreateOrConnectWithoutPaymentInput = {
    where: CommissionBatchItemWhereUniqueInput
    create: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput>
  }

  export type CommissionBatchItemCreateManyPaymentInputEnvelope = {
    data: CommissionBatchItemCreateManyPaymentInput | CommissionBatchItemCreateManyPaymentInput[]
    skipDuplicates?: boolean
  }

  export type ClaimUpsertWithoutPaymentInput = {
    update: XOR<ClaimUpdateWithoutPaymentInput, ClaimUncheckedUpdateWithoutPaymentInput>
    create: XOR<ClaimCreateWithoutPaymentInput, ClaimUncheckedCreateWithoutPaymentInput>
    where?: ClaimWhereInput
  }

  export type ClaimUpdateToOneWithWhereWithoutPaymentInput = {
    where?: ClaimWhereInput
    data: XOR<ClaimUpdateWithoutPaymentInput, ClaimUncheckedUpdateWithoutPaymentInput>
  }

  export type ClaimUpdateWithoutPaymentInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
  }

  export type PatientUpsertWithoutPaymentInput = {
    update: XOR<PatientUpdateWithoutPaymentInput, PatientUncheckedUpdateWithoutPaymentInput>
    create: XOR<PatientCreateWithoutPaymentInput, PatientUncheckedCreateWithoutPaymentInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutPaymentInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutPaymentInput, PatientUncheckedUpdateWithoutPaymentInput>
  }

  export type PatientUpdateWithoutPaymentInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type UserUpsertWithoutUpdatedPaymentsInput = {
    update: XOR<UserUpdateWithoutUpdatedPaymentsInput, UserUncheckedUpdateWithoutUpdatedPaymentsInput>
    create: XOR<UserCreateWithoutUpdatedPaymentsInput, UserUncheckedCreateWithoutUpdatedPaymentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutUpdatedPaymentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutUpdatedPaymentsInput, UserUncheckedUpdateWithoutUpdatedPaymentsInput>
  }

  export type UserUpdateWithoutUpdatedPaymentsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutUpdatedPaymentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type NpiProviderUpsertWithoutPaymentsInput = {
    update: XOR<NpiProviderUpdateWithoutPaymentsInput, NpiProviderUncheckedUpdateWithoutPaymentsInput>
    create: XOR<NpiProviderCreateWithoutPaymentsInput, NpiProviderUncheckedCreateWithoutPaymentsInput>
    where?: NpiProviderWhereInput
  }

  export type NpiProviderUpdateToOneWithWhereWithoutPaymentsInput = {
    where?: NpiProviderWhereInput
    data: XOR<NpiProviderUpdateWithoutPaymentsInput, NpiProviderUncheckedUpdateWithoutPaymentsInput>
  }

  export type NpiProviderUpdateWithoutPaymentsInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
    claims?: ClaimUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateWithoutPaymentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type ServiceLineTransactionUpsertWithWhereUniqueWithoutPaymentInput = {
    where: ServiceLineTransactionWhereUniqueInput
    update: XOR<ServiceLineTransactionUpdateWithoutPaymentInput, ServiceLineTransactionUncheckedUpdateWithoutPaymentInput>
    create: XOR<ServiceLineTransactionCreateWithoutPaymentInput, ServiceLineTransactionUncheckedCreateWithoutPaymentInput>
  }

  export type ServiceLineTransactionUpdateWithWhereUniqueWithoutPaymentInput = {
    where: ServiceLineTransactionWhereUniqueInput
    data: XOR<ServiceLineTransactionUpdateWithoutPaymentInput, ServiceLineTransactionUncheckedUpdateWithoutPaymentInput>
  }

  export type ServiceLineTransactionUpdateManyWithWhereWithoutPaymentInput = {
    where: ServiceLineTransactionScalarWhereInput
    data: XOR<ServiceLineTransactionUpdateManyMutationInput, ServiceLineTransactionUncheckedUpdateManyWithoutPaymentInput>
  }

  export type ServiceLineUpsertWithWhereUniqueWithoutPaymentInput = {
    where: ServiceLineWhereUniqueInput
    update: XOR<ServiceLineUpdateWithoutPaymentInput, ServiceLineUncheckedUpdateWithoutPaymentInput>
    create: XOR<ServiceLineCreateWithoutPaymentInput, ServiceLineUncheckedCreateWithoutPaymentInput>
  }

  export type ServiceLineUpdateWithWhereUniqueWithoutPaymentInput = {
    where: ServiceLineWhereUniqueInput
    data: XOR<ServiceLineUpdateWithoutPaymentInput, ServiceLineUncheckedUpdateWithoutPaymentInput>
  }

  export type ServiceLineUpdateManyWithWhereWithoutPaymentInput = {
    where: ServiceLineScalarWhereInput
    data: XOR<ServiceLineUpdateManyMutationInput, ServiceLineUncheckedUpdateManyWithoutPaymentInput>
  }

  export type CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput = {
    where: CommissionBatchItemWhereUniqueInput
    update: XOR<CommissionBatchItemUpdateWithoutPaymentInput, CommissionBatchItemUncheckedUpdateWithoutPaymentInput>
    create: XOR<CommissionBatchItemCreateWithoutPaymentInput, CommissionBatchItemUncheckedCreateWithoutPaymentInput>
  }

  export type CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput = {
    where: CommissionBatchItemWhereUniqueInput
    data: XOR<CommissionBatchItemUpdateWithoutPaymentInput, CommissionBatchItemUncheckedUpdateWithoutPaymentInput>
  }

  export type CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput = {
    where: CommissionBatchItemScalarWhereInput
    data: XOR<CommissionBatchItemUpdateManyMutationInput, CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput>
  }

  export type CommissionBatchItemScalarWhereInput = {
    AND?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
    OR?: CommissionBatchItemScalarWhereInput[]
    NOT?: CommissionBatchItemScalarWhereInput | CommissionBatchItemScalarWhereInput[]
    id?: IntFilter<"CommissionBatchItem"> | number
    commissionBatchId?: IntFilter<"CommissionBatchItem"> | number
    paymentId?: IntFilter<"CommissionBatchItem"> | number
    collectionAmount?: DecimalFilter<"CommissionBatchItem"> | Decimal | DecimalJsLike | number | string
  }

  export type PaymentCreateWithoutServiceLineTransactionsInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutServiceLineTransactionsInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
    commissionBatchItems?: CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutServiceLineTransactionsInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutServiceLineTransactionsInput, PaymentUncheckedCreateWithoutServiceLineTransactionsInput>
  }

  export type ServiceLineCreateWithoutServiceLineTransactionsInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
    claim?: ClaimCreateNestedOneWithoutServiceLinesInput
    payment?: PaymentCreateNestedOneWithoutServiceLinesInput
  }

  export type ServiceLineUncheckedCreateWithoutServiceLineTransactionsInput = {
    id?: number
    claimId?: number | null
    paymentId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
  }

  export type ServiceLineCreateOrConnectWithoutServiceLineTransactionsInput = {
    where: ServiceLineWhereUniqueInput
    create: XOR<ServiceLineCreateWithoutServiceLineTransactionsInput, ServiceLineUncheckedCreateWithoutServiceLineTransactionsInput>
  }

  export type PaymentUpsertWithoutServiceLineTransactionsInput = {
    update: XOR<PaymentUpdateWithoutServiceLineTransactionsInput, PaymentUncheckedUpdateWithoutServiceLineTransactionsInput>
    create: XOR<PaymentCreateWithoutServiceLineTransactionsInput, PaymentUncheckedCreateWithoutServiceLineTransactionsInput>
    where?: PaymentWhereInput
  }

  export type PaymentUpdateToOneWithWhereWithoutServiceLineTransactionsInput = {
    where?: PaymentWhereInput
    data: XOR<PaymentUpdateWithoutServiceLineTransactionsInput, PaymentUncheckedUpdateWithoutServiceLineTransactionsInput>
  }

  export type PaymentUpdateWithoutServiceLineTransactionsInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutServiceLineTransactionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type ServiceLineUpsertWithoutServiceLineTransactionsInput = {
    update: XOR<ServiceLineUpdateWithoutServiceLineTransactionsInput, ServiceLineUncheckedUpdateWithoutServiceLineTransactionsInput>
    create: XOR<ServiceLineCreateWithoutServiceLineTransactionsInput, ServiceLineUncheckedCreateWithoutServiceLineTransactionsInput>
    where?: ServiceLineWhereInput
  }

  export type ServiceLineUpdateToOneWithWhereWithoutServiceLineTransactionsInput = {
    where?: ServiceLineWhereInput
    data: XOR<ServiceLineUpdateWithoutServiceLineTransactionsInput, ServiceLineUncheckedUpdateWithoutServiceLineTransactionsInput>
  }

  export type ServiceLineUpdateWithoutServiceLineTransactionsInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    claim?: ClaimUpdateOneWithoutServiceLinesNestedInput
    payment?: PaymentUpdateOneWithoutServiceLinesNestedInput
  }

  export type ServiceLineUncheckedUpdateWithoutServiceLineTransactionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    paymentId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
  }

  export type UserCreateWithoutBackupsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutBackupsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutBackupsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutBackupsInput, UserUncheckedCreateWithoutBackupsInput>
  }

  export type UserUpsertWithoutBackupsInput = {
    update: XOR<UserUpdateWithoutBackupsInput, UserUncheckedUpdateWithoutBackupsInput>
    create: XOR<UserCreateWithoutBackupsInput, UserUncheckedCreateWithoutBackupsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutBackupsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutBackupsInput, UserUncheckedUpdateWithoutBackupsInput>
  }

  export type UserUpdateWithoutBackupsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutBackupsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutBackupDestinationsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutBackupDestinationsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutBackupDestinationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutBackupDestinationsInput, UserUncheckedCreateWithoutBackupDestinationsInput>
  }

  export type UserUpsertWithoutBackupDestinationsInput = {
    update: XOR<UserUpdateWithoutBackupDestinationsInput, UserUncheckedUpdateWithoutBackupDestinationsInput>
    create: XOR<UserCreateWithoutBackupDestinationsInput, UserUncheckedCreateWithoutBackupDestinationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutBackupDestinationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutBackupDestinationsInput, UserUncheckedUpdateWithoutBackupDestinationsInput>
  }

  export type UserUpdateWithoutBackupDestinationsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutBackupDestinationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutNotificationsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutNotificationsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutNotificationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
  }

  export type UserUpsertWithoutNotificationsInput = {
    update: XOR<UserUpdateWithoutNotificationsInput, UserUncheckedUpdateWithoutNotificationsInput>
    create: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutNotificationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutNotificationsInput, UserUncheckedUpdateWithoutNotificationsInput>
  }

  export type UserUpdateWithoutNotificationsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutNotificationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type CloudFolderCreateWithoutChildrenInput = {
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    parent?: CloudFolderCreateNestedOneWithoutChildrenInput
    user: UserCreateNestedOneWithoutCloudFoldersInput
    files?: CloudFileCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderUncheckedCreateWithoutChildrenInput = {
    id?: number
    userId: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    files?: CloudFileUncheckedCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderCreateOrConnectWithoutChildrenInput = {
    where: CloudFolderWhereUniqueInput
    create: XOR<CloudFolderCreateWithoutChildrenInput, CloudFolderUncheckedCreateWithoutChildrenInput>
  }

  export type CloudFolderCreateWithoutParentInput = {
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    children?: CloudFolderCreateNestedManyWithoutParentInput
    user: UserCreateNestedOneWithoutCloudFoldersInput
    files?: CloudFileCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderUncheckedCreateWithoutParentInput = {
    id?: number
    userId: number
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    children?: CloudFolderUncheckedCreateNestedManyWithoutParentInput
    files?: CloudFileUncheckedCreateNestedManyWithoutFolderInput
  }

  export type CloudFolderCreateOrConnectWithoutParentInput = {
    where: CloudFolderWhereUniqueInput
    create: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput>
  }

  export type CloudFolderCreateManyParentInputEnvelope = {
    data: CloudFolderCreateManyParentInput | CloudFolderCreateManyParentInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutCloudFoldersInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCloudFoldersInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCloudFoldersInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCloudFoldersInput, UserUncheckedCreateWithoutCloudFoldersInput>
  }

  export type CloudFileCreateWithoutFolderInput = {
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutCloudFilesInput
    chunks?: CloudFileChunkCreateNestedManyWithoutFileInput
  }

  export type CloudFileUncheckedCreateWithoutFolderInput = {
    id?: number
    userId: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    chunks?: CloudFileChunkUncheckedCreateNestedManyWithoutFileInput
  }

  export type CloudFileCreateOrConnectWithoutFolderInput = {
    where: CloudFileWhereUniqueInput
    create: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput>
  }

  export type CloudFileCreateManyFolderInputEnvelope = {
    data: CloudFileCreateManyFolderInput | CloudFileCreateManyFolderInput[]
    skipDuplicates?: boolean
  }

  export type CloudFolderUpsertWithoutChildrenInput = {
    update: XOR<CloudFolderUpdateWithoutChildrenInput, CloudFolderUncheckedUpdateWithoutChildrenInput>
    create: XOR<CloudFolderCreateWithoutChildrenInput, CloudFolderUncheckedCreateWithoutChildrenInput>
    where?: CloudFolderWhereInput
  }

  export type CloudFolderUpdateToOneWithWhereWithoutChildrenInput = {
    where?: CloudFolderWhereInput
    data: XOR<CloudFolderUpdateWithoutChildrenInput, CloudFolderUncheckedUpdateWithoutChildrenInput>
  }

  export type CloudFolderUpdateWithoutChildrenInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    parent?: CloudFolderUpdateOneWithoutChildrenNestedInput
    user?: UserUpdateOneRequiredWithoutCloudFoldersNestedInput
    files?: CloudFileUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateWithoutChildrenInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    files?: CloudFileUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUpsertWithWhereUniqueWithoutParentInput = {
    where: CloudFolderWhereUniqueInput
    update: XOR<CloudFolderUpdateWithoutParentInput, CloudFolderUncheckedUpdateWithoutParentInput>
    create: XOR<CloudFolderCreateWithoutParentInput, CloudFolderUncheckedCreateWithoutParentInput>
  }

  export type CloudFolderUpdateWithWhereUniqueWithoutParentInput = {
    where: CloudFolderWhereUniqueInput
    data: XOR<CloudFolderUpdateWithoutParentInput, CloudFolderUncheckedUpdateWithoutParentInput>
  }

  export type CloudFolderUpdateManyWithWhereWithoutParentInput = {
    where: CloudFolderScalarWhereInput
    data: XOR<CloudFolderUpdateManyMutationInput, CloudFolderUncheckedUpdateManyWithoutParentInput>
  }

  export type UserUpsertWithoutCloudFoldersInput = {
    update: XOR<UserUpdateWithoutCloudFoldersInput, UserUncheckedUpdateWithoutCloudFoldersInput>
    create: XOR<UserCreateWithoutCloudFoldersInput, UserUncheckedCreateWithoutCloudFoldersInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutCloudFoldersInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutCloudFoldersInput, UserUncheckedUpdateWithoutCloudFoldersInput>
  }

  export type UserUpdateWithoutCloudFoldersInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCloudFoldersInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type CloudFileUpsertWithWhereUniqueWithoutFolderInput = {
    where: CloudFileWhereUniqueInput
    update: XOR<CloudFileUpdateWithoutFolderInput, CloudFileUncheckedUpdateWithoutFolderInput>
    create: XOR<CloudFileCreateWithoutFolderInput, CloudFileUncheckedCreateWithoutFolderInput>
  }

  export type CloudFileUpdateWithWhereUniqueWithoutFolderInput = {
    where: CloudFileWhereUniqueInput
    data: XOR<CloudFileUpdateWithoutFolderInput, CloudFileUncheckedUpdateWithoutFolderInput>
  }

  export type CloudFileUpdateManyWithWhereWithoutFolderInput = {
    where: CloudFileScalarWhereInput
    data: XOR<CloudFileUpdateManyMutationInput, CloudFileUncheckedUpdateManyWithoutFolderInput>
  }

  export type UserCreateWithoutCloudFilesInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCloudFilesInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCloudFilesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCloudFilesInput, UserUncheckedCreateWithoutCloudFilesInput>
  }

  export type CloudFolderCreateWithoutFilesInput = {
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    parent?: CloudFolderCreateNestedOneWithoutChildrenInput
    children?: CloudFolderCreateNestedManyWithoutParentInput
    user: UserCreateNestedOneWithoutCloudFoldersInput
  }

  export type CloudFolderUncheckedCreateWithoutFilesInput = {
    id?: number
    userId: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    children?: CloudFolderUncheckedCreateNestedManyWithoutParentInput
  }

  export type CloudFolderCreateOrConnectWithoutFilesInput = {
    where: CloudFolderWhereUniqueInput
    create: XOR<CloudFolderCreateWithoutFilesInput, CloudFolderUncheckedCreateWithoutFilesInput>
  }

  export type CloudFileChunkCreateWithoutFileInput = {
    seq: number
    data: Bytes
    createdAt?: Date | string
  }

  export type CloudFileChunkUncheckedCreateWithoutFileInput = {
    id?: number
    seq: number
    data: Bytes
    createdAt?: Date | string
  }

  export type CloudFileChunkCreateOrConnectWithoutFileInput = {
    where: CloudFileChunkWhereUniqueInput
    create: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput>
  }

  export type CloudFileChunkCreateManyFileInputEnvelope = {
    data: CloudFileChunkCreateManyFileInput | CloudFileChunkCreateManyFileInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutCloudFilesInput = {
    update: XOR<UserUpdateWithoutCloudFilesInput, UserUncheckedUpdateWithoutCloudFilesInput>
    create: XOR<UserCreateWithoutCloudFilesInput, UserUncheckedCreateWithoutCloudFilesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutCloudFilesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutCloudFilesInput, UserUncheckedUpdateWithoutCloudFilesInput>
  }

  export type UserUpdateWithoutCloudFilesInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCloudFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type CloudFolderUpsertWithoutFilesInput = {
    update: XOR<CloudFolderUpdateWithoutFilesInput, CloudFolderUncheckedUpdateWithoutFilesInput>
    create: XOR<CloudFolderCreateWithoutFilesInput, CloudFolderUncheckedCreateWithoutFilesInput>
    where?: CloudFolderWhereInput
  }

  export type CloudFolderUpdateToOneWithWhereWithoutFilesInput = {
    where?: CloudFolderWhereInput
    data: XOR<CloudFolderUpdateWithoutFilesInput, CloudFolderUncheckedUpdateWithoutFilesInput>
  }

  export type CloudFolderUpdateWithoutFilesInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    parent?: CloudFolderUpdateOneWithoutChildrenNestedInput
    children?: CloudFolderUpdateManyWithoutParentNestedInput
    user?: UserUpdateOneRequiredWithoutCloudFoldersNestedInput
  }

  export type CloudFolderUncheckedUpdateWithoutFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    children?: CloudFolderUncheckedUpdateManyWithoutParentNestedInput
  }

  export type CloudFileChunkUpsertWithWhereUniqueWithoutFileInput = {
    where: CloudFileChunkWhereUniqueInput
    update: XOR<CloudFileChunkUpdateWithoutFileInput, CloudFileChunkUncheckedUpdateWithoutFileInput>
    create: XOR<CloudFileChunkCreateWithoutFileInput, CloudFileChunkUncheckedCreateWithoutFileInput>
  }

  export type CloudFileChunkUpdateWithWhereUniqueWithoutFileInput = {
    where: CloudFileChunkWhereUniqueInput
    data: XOR<CloudFileChunkUpdateWithoutFileInput, CloudFileChunkUncheckedUpdateWithoutFileInput>
  }

  export type CloudFileChunkUpdateManyWithWhereWithoutFileInput = {
    where: CloudFileChunkScalarWhereInput
    data: XOR<CloudFileChunkUpdateManyMutationInput, CloudFileChunkUncheckedUpdateManyWithoutFileInput>
  }

  export type CloudFileChunkScalarWhereInput = {
    AND?: CloudFileChunkScalarWhereInput | CloudFileChunkScalarWhereInput[]
    OR?: CloudFileChunkScalarWhereInput[]
    NOT?: CloudFileChunkScalarWhereInput | CloudFileChunkScalarWhereInput[]
    id?: IntFilter<"CloudFileChunk"> | number
    fileId?: IntFilter<"CloudFileChunk"> | number
    seq?: IntFilter<"CloudFileChunk"> | number
    data?: BytesFilter<"CloudFileChunk"> | Bytes
    createdAt?: DateTimeFilter<"CloudFileChunk"> | Date | string
  }

  export type CloudFileCreateWithoutChunksInput = {
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutCloudFilesInput
    folder?: CloudFolderCreateNestedOneWithoutFilesInput
  }

  export type CloudFileUncheckedCreateWithoutChunksInput = {
    id?: number
    userId: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    folderId?: number | null
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFileCreateOrConnectWithoutChunksInput = {
    where: CloudFileWhereUniqueInput
    create: XOR<CloudFileCreateWithoutChunksInput, CloudFileUncheckedCreateWithoutChunksInput>
  }

  export type CloudFileUpsertWithoutChunksInput = {
    update: XOR<CloudFileUpdateWithoutChunksInput, CloudFileUncheckedUpdateWithoutChunksInput>
    create: XOR<CloudFileCreateWithoutChunksInput, CloudFileUncheckedCreateWithoutChunksInput>
    where?: CloudFileWhereInput
  }

  export type CloudFileUpdateToOneWithWhereWithoutChunksInput = {
    where?: CloudFileWhereInput
    data: XOR<CloudFileUpdateWithoutChunksInput, CloudFileUncheckedUpdateWithoutChunksInput>
  }

  export type CloudFileUpdateWithoutChunksInput = {
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutCloudFilesNestedInput
    folder?: CloudFolderUpdateOneWithoutFilesNestedInput
  }

  export type CloudFileUncheckedUpdateWithoutChunksInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    folderId?: NullableIntFieldUpdateOperationsInput | number | null
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientCreateWithoutCommunicationsInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutCommunicationsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutCommunicationsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutCommunicationsInput, PatientUncheckedCreateWithoutCommunicationsInput>
  }

  export type UserCreateWithoutCommunicationsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCommunicationsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCommunicationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCommunicationsInput, UserUncheckedCreateWithoutCommunicationsInput>
  }

  export type PatientUpsertWithoutCommunicationsInput = {
    update: XOR<PatientUpdateWithoutCommunicationsInput, PatientUncheckedUpdateWithoutCommunicationsInput>
    create: XOR<PatientCreateWithoutCommunicationsInput, PatientUncheckedCreateWithoutCommunicationsInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutCommunicationsInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutCommunicationsInput, PatientUncheckedUpdateWithoutCommunicationsInput>
  }

  export type PatientUpdateWithoutCommunicationsInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutCommunicationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type UserUpsertWithoutCommunicationsInput = {
    update: XOR<UserUpdateWithoutCommunicationsInput, UserUncheckedUpdateWithoutCommunicationsInput>
    create: XOR<UserCreateWithoutCommunicationsInput, UserUncheckedCreateWithoutCommunicationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutCommunicationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutCommunicationsInput, UserUncheckedUpdateWithoutCommunicationsInput>
  }

  export type UserUpdateWithoutCommunicationsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCommunicationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PatientCreateWithoutDocumentsInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationCreateNestedOneWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutDocumentsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    conversation?: PatientConversationUncheckedCreateNestedOneWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutDocumentsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutDocumentsInput, PatientUncheckedCreateWithoutDocumentsInput>
  }

  export type PatientUpsertWithoutDocumentsInput = {
    update: XOR<PatientUpdateWithoutDocumentsInput, PatientUncheckedUpdateWithoutDocumentsInput>
    create: XOR<PatientCreateWithoutDocumentsInput, PatientUncheckedCreateWithoutDocumentsInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutDocumentsInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutDocumentsInput, PatientUncheckedUpdateWithoutDocumentsInput>
  }

  export type PatientUpdateWithoutDocumentsInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutDocumentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type UserCreateWithoutTwilioSettingsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutTwilioSettingsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutTwilioSettingsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutTwilioSettingsInput, UserUncheckedCreateWithoutTwilioSettingsInput>
  }

  export type UserUpsertWithoutTwilioSettingsInput = {
    update: XOR<UserUpdateWithoutTwilioSettingsInput, UserUncheckedUpdateWithoutTwilioSettingsInput>
    create: XOR<UserCreateWithoutTwilioSettingsInput, UserUncheckedCreateWithoutTwilioSettingsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutTwilioSettingsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutTwilioSettingsInput, UserUncheckedUpdateWithoutTwilioSettingsInput>
  }

  export type UserUpdateWithoutTwilioSettingsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutTwilioSettingsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutAiSettingsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAiSettingsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAiSettingsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAiSettingsInput, UserUncheckedCreateWithoutAiSettingsInput>
  }

  export type UserUpsertWithoutAiSettingsInput = {
    update: XOR<UserUpdateWithoutAiSettingsInput, UserUncheckedUpdateWithoutAiSettingsInput>
    create: XOR<UserCreateWithoutAiSettingsInput, UserUncheckedCreateWithoutAiSettingsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAiSettingsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAiSettingsInput, UserUncheckedUpdateWithoutAiSettingsInput>
  }

  export type UserUpdateWithoutAiSettingsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAiSettingsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutOfficeHoursInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutOfficeHoursInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutOfficeHoursInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutOfficeHoursInput, UserUncheckedCreateWithoutOfficeHoursInput>
  }

  export type UserUpsertWithoutOfficeHoursInput = {
    update: XOR<UserUpdateWithoutOfficeHoursInput, UserUncheckedUpdateWithoutOfficeHoursInput>
    create: XOR<UserCreateWithoutOfficeHoursInput, UserUncheckedCreateWithoutOfficeHoursInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutOfficeHoursInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutOfficeHoursInput, UserUncheckedUpdateWithoutOfficeHoursInput>
  }

  export type UserUpdateWithoutOfficeHoursInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutOfficeHoursInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutOfficeContactInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutOfficeContactInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutOfficeContactInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutOfficeContactInput, UserUncheckedCreateWithoutOfficeContactInput>
  }

  export type UserUpsertWithoutOfficeContactInput = {
    update: XOR<UserUpdateWithoutOfficeContactInput, UserUncheckedUpdateWithoutOfficeContactInput>
    create: XOR<UserCreateWithoutOfficeContactInput, UserUncheckedCreateWithoutOfficeContactInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutOfficeContactInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutOfficeContactInput, UserUncheckedUpdateWithoutOfficeContactInput>
  }

  export type UserUpdateWithoutOfficeContactInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutOfficeContactInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutInsuranceContactsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutInsuranceContactsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutInsuranceContactsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutInsuranceContactsInput, UserUncheckedCreateWithoutInsuranceContactsInput>
  }

  export type UserUpsertWithoutInsuranceContactsInput = {
    update: XOR<UserUpdateWithoutInsuranceContactsInput, UserUncheckedUpdateWithoutInsuranceContactsInput>
    create: XOR<UserCreateWithoutInsuranceContactsInput, UserUncheckedCreateWithoutInsuranceContactsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutInsuranceContactsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutInsuranceContactsInput, UserUncheckedUpdateWithoutInsuranceContactsInput>
  }

  export type UserUpdateWithoutInsuranceContactsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutInsuranceContactsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutProcedureTimeslotInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutProcedureTimeslotInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
    patientConversations?: PatientConversationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutProcedureTimeslotInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutProcedureTimeslotInput, UserUncheckedCreateWithoutProcedureTimeslotInput>
  }

  export type UserUpsertWithoutProcedureTimeslotInput = {
    update: XOR<UserUpdateWithoutProcedureTimeslotInput, UserUncheckedUpdateWithoutProcedureTimeslotInput>
    create: XOR<UserCreateWithoutProcedureTimeslotInput, UserUncheckedCreateWithoutProcedureTimeslotInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutProcedureTimeslotInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutProcedureTimeslotInput, UserUncheckedUpdateWithoutProcedureTimeslotInput>
  }

  export type UserUpdateWithoutProcedureTimeslotInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutProcedureTimeslotInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
    patientConversations?: PatientConversationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PatientCreateWithoutConversationInput = {
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutConversationInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    updatedAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutConversationInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutConversationInput, PatientUncheckedCreateWithoutConversationInput>
  }

  export type UserCreateWithoutPatientConversationsInput = {
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPatientConversationsInput = {
    id?: number
    username: string
    password: string
    autoBackupEnabled?: boolean
    usbBackupEnabled?: boolean
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    shoppingVendors?: ShoppingVendorUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
    twilioSettings?: TwilioSettingsUncheckedCreateNestedOneWithoutUserInput
    aiSettings?: AiSettingsUncheckedCreateNestedOneWithoutUserInput
    officeHours?: OfficeHoursUncheckedCreateNestedOneWithoutUserInput
    officeContact?: OfficeContactUncheckedCreateNestedOneWithoutUserInput
    procedureTimeslot?: ProcedureTimeslotUncheckedCreateNestedOneWithoutUserInput
    insuranceContacts?: InsuranceContactUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPatientConversationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPatientConversationsInput, UserUncheckedCreateWithoutPatientConversationsInput>
  }

  export type PatientUpsertWithoutConversationInput = {
    update: XOR<PatientUpdateWithoutConversationInput, PatientUncheckedUpdateWithoutConversationInput>
    create: XOR<PatientCreateWithoutConversationInput, PatientUncheckedCreateWithoutConversationInput>
    where?: PatientWhereInput
  }

  export type PatientUpdateToOneWithWhereWithoutConversationInput = {
    where?: PatientWhereInput
    data: XOR<PatientUpdateWithoutConversationInput, PatientUncheckedUpdateWithoutConversationInput>
  }

  export type PatientUpdateWithoutConversationInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutConversationInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  export type UserUpsertWithoutPatientConversationsInput = {
    update: XOR<UserUpdateWithoutPatientConversationsInput, UserUncheckedUpdateWithoutPatientConversationsInput>
    create: XOR<UserCreateWithoutPatientConversationsInput, UserUncheckedCreateWithoutPatientConversationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPatientConversationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPatientConversationsInput, UserUncheckedUpdateWithoutPatientConversationsInput>
  }

  export type UserUpdateWithoutPatientConversationsInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPatientConversationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    autoBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    usbBackupEnabled?: BoolFieldUpdateOperationsInput | boolean
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    shoppingVendors?: ShoppingVendorUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
    twilioSettings?: TwilioSettingsUncheckedUpdateOneWithoutUserNestedInput
    aiSettings?: AiSettingsUncheckedUpdateOneWithoutUserNestedInput
    officeHours?: OfficeHoursUncheckedUpdateOneWithoutUserNestedInput
    officeContact?: OfficeContactUncheckedUpdateOneWithoutUserNestedInput
    procedureTimeslot?: ProcedureTimeslotUncheckedUpdateOneWithoutUserNestedInput
    insuranceContacts?: InsuranceContactUncheckedUpdateManyWithoutUserNestedInput
  }

  export type NpiProviderCreateWithoutCommissionBatchesInput = {
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutNpiProvidersInput
    claims?: ClaimCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderUncheckedCreateWithoutCommissionBatchesInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
    claims?: ClaimUncheckedCreateNestedManyWithoutNpiProviderInput
    payments?: PaymentUncheckedCreateNestedManyWithoutNpiProviderInput
    appointmentProcedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutNpiProviderInput
  }

  export type NpiProviderCreateOrConnectWithoutCommissionBatchesInput = {
    where: NpiProviderWhereUniqueInput
    create: XOR<NpiProviderCreateWithoutCommissionBatchesInput, NpiProviderUncheckedCreateWithoutCommissionBatchesInput>
  }

  export type CommissionBatchItemCreateWithoutCommissionBatchInput = {
    collectionAmount: Decimal | DecimalJsLike | number | string
    payment: PaymentCreateNestedOneWithoutCommissionBatchItemsInput
  }

  export type CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput = {
    id?: number
    paymentId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput = {
    where: CommissionBatchItemWhereUniqueInput
    create: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput>
  }

  export type CommissionBatchItemCreateManyCommissionBatchInputEnvelope = {
    data: CommissionBatchItemCreateManyCommissionBatchInput | CommissionBatchItemCreateManyCommissionBatchInput[]
    skipDuplicates?: boolean
  }

  export type NpiProviderUpsertWithoutCommissionBatchesInput = {
    update: XOR<NpiProviderUpdateWithoutCommissionBatchesInput, NpiProviderUncheckedUpdateWithoutCommissionBatchesInput>
    create: XOR<NpiProviderCreateWithoutCommissionBatchesInput, NpiProviderUncheckedCreateWithoutCommissionBatchesInput>
    where?: NpiProviderWhereInput
  }

  export type NpiProviderUpdateToOneWithWhereWithoutCommissionBatchesInput = {
    where?: NpiProviderWhereInput
    data: XOR<NpiProviderUpdateWithoutCommissionBatchesInput, NpiProviderUncheckedUpdateWithoutCommissionBatchesInput>
  }

  export type NpiProviderUpdateWithoutCommissionBatchesInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
    claims?: ClaimUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateWithoutCommissionBatchesInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput = {
    where: CommissionBatchItemWhereUniqueInput
    update: XOR<CommissionBatchItemUpdateWithoutCommissionBatchInput, CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput>
    create: XOR<CommissionBatchItemCreateWithoutCommissionBatchInput, CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput>
  }

  export type CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput = {
    where: CommissionBatchItemWhereUniqueInput
    data: XOR<CommissionBatchItemUpdateWithoutCommissionBatchInput, CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput>
  }

  export type CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput = {
    where: CommissionBatchItemScalarWhereInput
    data: XOR<CommissionBatchItemUpdateManyMutationInput, CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput>
  }

  export type CommissionBatchCreateWithoutItemsInput = {
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
    npiProvider: NpiProviderCreateNestedOneWithoutCommissionBatchesInput
  }

  export type CommissionBatchUncheckedCreateWithoutItemsInput = {
    id?: number
    npiProviderId: number
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
  }

  export type CommissionBatchCreateOrConnectWithoutItemsInput = {
    where: CommissionBatchWhereUniqueInput
    create: XOR<CommissionBatchCreateWithoutItemsInput, CommissionBatchUncheckedCreateWithoutItemsInput>
  }

  export type PaymentCreateWithoutCommissionBatchItemsInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    npiProvider?: NpiProviderCreateNestedOneWithoutPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutCommissionBatchItemsInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
  }

  export type PaymentCreateOrConnectWithoutCommissionBatchItemsInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutCommissionBatchItemsInput, PaymentUncheckedCreateWithoutCommissionBatchItemsInput>
  }

  export type CommissionBatchUpsertWithoutItemsInput = {
    update: XOR<CommissionBatchUpdateWithoutItemsInput, CommissionBatchUncheckedUpdateWithoutItemsInput>
    create: XOR<CommissionBatchCreateWithoutItemsInput, CommissionBatchUncheckedCreateWithoutItemsInput>
    where?: CommissionBatchWhereInput
  }

  export type CommissionBatchUpdateToOneWithWhereWithoutItemsInput = {
    where?: CommissionBatchWhereInput
    data: XOR<CommissionBatchUpdateWithoutItemsInput, CommissionBatchUncheckedUpdateWithoutItemsInput>
  }

  export type CommissionBatchUpdateWithoutItemsInput = {
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    npiProvider?: NpiProviderUpdateOneRequiredWithoutCommissionBatchesNestedInput
  }

  export type CommissionBatchUncheckedUpdateWithoutItemsInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiProviderId?: IntFieldUpdateOperationsInput | number
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUpsertWithoutCommissionBatchItemsInput = {
    update: XOR<PaymentUpdateWithoutCommissionBatchItemsInput, PaymentUncheckedUpdateWithoutCommissionBatchItemsInput>
    create: XOR<PaymentCreateWithoutCommissionBatchItemsInput, PaymentUncheckedCreateWithoutCommissionBatchItemsInput>
    where?: PaymentWhereInput
  }

  export type PaymentUpdateToOneWithWhereWithoutCommissionBatchItemsInput = {
    where?: PaymentWhereInput
    data: XOR<PaymentUpdateWithoutCommissionBatchItemsInput, PaymentUncheckedUpdateWithoutCommissionBatchItemsInput>
  }

  export type PaymentUpdateWithoutCommissionBatchItemsInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutCommissionBatchItemsInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type PatientCreateManyUserInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth?: Date | string | null
    gender: string
    phone: string
    email?: string | null
    address?: string | null
    city?: string | null
    zipCode?: string | null
    insuranceProvider?: string | null
    insuranceId?: string | null
    groupNumber?: string | null
    policyHolder?: string | null
    allergies?: string | null
    medicalConditions?: string | null
    preferredLanguage?: string | null
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentCreateManyUserInput = {
    id?: number
    patientId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type StaffCreateManyUserInput = {
    id?: number
    name: string
    email?: string | null
    role: string
    phone?: string | null
    createdAt?: Date | string
  }

  export type NpiProviderCreateManyUserInput = {
    id?: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
  }

  export type ClaimCreateManyUserInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
  }

  export type InsuranceCredentialCreateManyUserInput = {
    id?: number
    siteKey: string
    username: string
    password: string
  }

  export type ShoppingVendorCreateManyUserInput = {
    id?: number
    vendorName: string
    websiteUrl: string
    loginUsername: string
    loginPassword: string
  }

  export type PaymentCreateManyUpdatedByInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type DatabaseBackupCreateManyUserInput = {
    id?: number
    createdAt?: Date | string
  }

  export type BackupDestinationCreateManyUserInput = {
    id?: number
    path: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type NotificationCreateManyUserInput = {
    id?: number
    type: $Enums.NotificationTypes
    message: string
    createdAt?: Date | string
    read?: boolean
  }

  export type CloudFolderCreateManyUserInput = {
    id?: number
    name: string
    parentId?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFileCreateManyUserInput = {
    id?: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    folderId?: number | null
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommunicationCreateManyUserInput = {
    id?: number
    patientId: number
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type InsuranceContactCreateManyUserInput = {
    id?: number
    name: string
    phoneNumber?: string | null
    createdAt?: Date | string
  }

  export type PatientConversationCreateManyUserInput = {
    id?: number
    patientId: number
    stage?: string
    aiHandoff?: boolean
    updatedAt?: Date | string
  }

  export type PatientUpdateWithoutUserInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
    conversation?: PatientConversationUncheckedUpdateOneWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    gender?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    zipCode?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceProvider?: NullableStringFieldUpdateOperationsInput | string | null
    insuranceId?: NullableStringFieldUpdateOperationsInput | string | null
    groupNumber?: NullableStringFieldUpdateOperationsInput | string | null
    policyHolder?: NullableStringFieldUpdateOperationsInput | string | null
    allergies?: NullableStringFieldUpdateOperationsInput | string | null
    medicalConditions?: NullableStringFieldUpdateOperationsInput | string | null
    preferredLanguage?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUpdateWithoutUserInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  export type StaffUpdateWithoutUserInput = {
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUpdateManyWithoutStaffNestedInput
    claims?: ClaimUpdateManyWithoutStaffNestedInput
  }

  export type StaffUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutStaffNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutStaffNestedInput
  }

  export type StaffUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NpiProviderUpdateWithoutUserInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claims?: ClaimUncheckedUpdateManyWithoutNpiProviderNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutNpiProviderNestedInput
    commissionBatches?: CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput
    appointmentProcedures?: AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderNestedInput
  }

  export type NpiProviderUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ClaimUpdateWithoutUserInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type InsuranceCredentialUpdateWithoutUserInput = {
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type InsuranceCredentialUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type InsuranceCredentialUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    siteKey?: StringFieldUpdateOperationsInput | string
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorUpdateWithoutUserInput = {
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type ShoppingVendorUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    vendorName?: StringFieldUpdateOperationsInput | string
    websiteUrl?: StringFieldUpdateOperationsInput | string
    loginUsername?: StringFieldUpdateOperationsInput | string
    loginPassword?: StringFieldUpdateOperationsInput | string
  }

  export type PaymentUpdateWithoutUpdatedByInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutUpdatedByInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateManyWithoutUpdatedByInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DatabaseBackupUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationUpdateWithoutUserInput = {
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BackupDestinationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    path?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUpdateWithoutUserInput = {
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: EnumNotificationTypesFieldUpdateOperationsInput | $Enums.NotificationTypes
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    read?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CloudFolderUpdateWithoutUserInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    parent?: CloudFolderUpdateOneWithoutChildrenNestedInput
    children?: CloudFolderUpdateManyWithoutParentNestedInput
    files?: CloudFileUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    children?: CloudFolderUncheckedUpdateManyWithoutParentNestedInput
    files?: CloudFileUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    parentId?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileUpdateWithoutUserInput = {
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folder?: CloudFolderUpdateOneWithoutFilesNestedInput
    chunks?: CloudFileChunkUpdateManyWithoutFileNestedInput
  }

  export type CloudFileUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    folderId?: NullableIntFieldUpdateOperationsInput | number | null
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chunks?: CloudFileChunkUncheckedUpdateManyWithoutFileNestedInput
  }

  export type CloudFileUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    folderId?: NullableIntFieldUpdateOperationsInput | number | null
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationUpdateWithoutUserInput = {
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutCommunicationsNestedInput
  }

  export type CommunicationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type InsuranceContactUpdateWithoutUserInput = {
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type InsuranceContactUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type InsuranceContactUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    phoneNumber?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientConversationUpdateWithoutUserInput = {
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutConversationNestedInput
  }

  export type PatientConversationUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientConversationUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    stage?: StringFieldUpdateOperationsInput | string
    aiHandoff?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateManyPatientInput = {
    id?: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type AppointmentProcedureCreateManyPatientInput = {
    id?: number
    appointmentId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type ClaimCreateManyPatientInput = {
    id?: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
  }

  export type PdfGroupCreateManyPatientInput = {
    id?: number
    title: string
    titleKey?: $Enums.PdfTitleKey
    createdAt?: Date | string
  }

  export type PaymentCreateManyPatientInput = {
    id?: number
    claimId?: number | null
    userId: number
    updatedById?: number | null
    npiProviderId?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommunicationCreateManyPatientInput = {
    id?: number
    userId?: number | null
    channel: $Enums.CommunicationChannel
    direction: $Enums.CommunicationDirection
    status: $Enums.CommunicationStatus
    body?: string | null
    callDuration?: number | null
    twilioSid?: string | null
    createdAt?: Date | string
  }

  export type PatientDocumentCreateManyPatientInput = {
    id?: number
    filename: string
    originalName: string
    mimeType: string
    fileSize: bigint | number
    filePath: string
    uploadedAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentUpdateWithoutPatientInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  export type AppointmentProcedureUpdateWithoutPatientInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointment?: AppointmentUpdateOneRequiredWithoutProceduresNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutAppointmentProceduresNestedInput
  }

  export type AppointmentProcedureUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ClaimUpdateWithoutPatientInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type PdfGroupUpdateWithoutPatientInput = {
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    pdfs?: PdfFileUpdateManyWithoutGroupNestedInput
  }

  export type PdfGroupUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    pdfs?: PdfFileUncheckedUpdateManyWithoutGroupNestedInput
  }

  export type PdfGroupUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    titleKey?: EnumPdfTitleKeyFieldUpdateOperationsInput | $Enums.PdfTitleKey
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUpdateWithoutPatientInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationUpdateWithoutPatientInput = {
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutCommunicationsNestedInput
  }

  export type CommunicationUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: NullableIntFieldUpdateOperationsInput | number | null
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommunicationUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: NullableIntFieldUpdateOperationsInput | number | null
    channel?: EnumCommunicationChannelFieldUpdateOperationsInput | $Enums.CommunicationChannel
    direction?: EnumCommunicationDirectionFieldUpdateOperationsInput | $Enums.CommunicationDirection
    status?: EnumCommunicationStatusFieldUpdateOperationsInput | $Enums.CommunicationStatus
    body?: NullableStringFieldUpdateOperationsInput | string | null
    callDuration?: NullableIntFieldUpdateOperationsInput | number | null
    twilioSid?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentUpdateWithoutPatientInput = {
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientDocumentUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    filePath?: StringFieldUpdateOperationsInput | string
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureCreateManyAppointmentInput = {
    id?: number
    patientId: number
    npiProviderId?: number | null
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type ClaimCreateManyAppointmentInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
  }

  export type AppointmentFileCreateManyAppointmentInput = {
    id?: number
    filename: string
    mimeType?: string | null
    filePath?: string | null
  }

  export type AppointmentProcedureUpdateWithoutAppointmentInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutProceduresNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutAppointmentProceduresNestedInput
  }

  export type AppointmentProcedureUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ClaimUpdateWithoutAppointmentInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type AppointmentFileUpdateWithoutAppointmentInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentFileUncheckedUpdateWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentFileUncheckedUpdateManyWithoutAppointmentInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentCreateManyStaffInput = {
    id?: number
    patientId: number
    userId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    typeLocked?: boolean
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    movedByAi?: boolean
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type ClaimCreateManyStaffInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
    npiProviderId?: number | null
  }

  export type AppointmentUpdateWithoutStaffInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
    files?: AppointmentFileUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateManyWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    typeLocked?: BoolFieldUpdateOperationsInput | boolean
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    movedByAi?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  export type ClaimUpdateWithoutStaffInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    npiProvider?: NpiProviderUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    npiProviderId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ClaimCreateManyNpiProviderInput = {
    id?: number
    patientId: number
    appointmentId?: number | null
    userId: number
    staffId: number
    patientName: string
    memberId: string
    dateOfBirth: Date | string
    remarks: string
    missingTeethStatus?: $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate: Date | string
    insuranceProvider: string
    createdAt?: Date | string
    updatedAt?: Date | string
    status?: $Enums.ClaimStatus
    claimNumber?: string | null
    preAuthNumber?: string | null
  }

  export type PaymentCreateManyNpiProviderInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    updatedById?: number | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    mhPaidAmount?: Decimal | DecimalJsLike | number | string | null
    copayment?: Decimal | DecimalJsLike | number | string
    adjustment?: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommissionBatchCreateManyNpiProviderInput = {
    id?: number
    totalCollection: Decimal | DecimalJsLike | number | string
    commissionAmount: Decimal | DecimalJsLike | number | string
    notes?: string | null
    createdAt?: Date | string
  }

  export type AppointmentProcedureCreateManyNpiProviderInput = {
    id?: number
    appointmentId: number
    patientId: number
    procedureCode: string
    procedureLabel?: string | null
    fee?: Decimal | DecimalJsLike | number | string | null
    category?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    oralCavityArea?: string | null
    source?: $Enums.ProcedureSource
    comboKey?: string | null
    createdAt?: Date | string
  }

  export type ClaimUpdateWithoutNpiProviderInput = {
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: NullableIntFieldUpdateOperationsInput | number | null
    userId?: IntFieldUpdateOperationsInput | number
    staffId?: IntFieldUpdateOperationsInput | number
    patientName?: StringFieldUpdateOperationsInput | string
    memberId?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    remarks?: StringFieldUpdateOperationsInput | string
    missingTeethStatus?: EnumMissingTeethStatusFieldUpdateOperationsInput | $Enums.MissingTeethStatus
    missingTeeth?: NullableJsonNullValueInput | InputJsonValue
    serviceDate?: DateTimeFieldUpdateOperationsInput | Date | string
    insuranceProvider?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumClaimStatusFieldUpdateOperationsInput | $Enums.ClaimStatus
    claimNumber?: NullableStringFieldUpdateOperationsInput | string | null
    preAuthNumber?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type PaymentUpdateWithoutNpiProviderInput = {
    userId?: IntFieldUpdateOperationsInput | number
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
    commissionBatchItems?: CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateManyWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    updatedById?: NullableIntFieldUpdateOperationsInput | number | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    mhPaidAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    copayment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustment?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommissionBatchUpdateWithoutNpiProviderInput = {
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput
  }

  export type CommissionBatchUncheckedUpdateWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput
  }

  export type CommissionBatchUncheckedUpdateManyWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    totalCollection?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureUpdateWithoutNpiProviderInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointment?: AppointmentUpdateOneRequiredWithoutProceduresNestedInput
    patient?: PatientUpdateOneRequiredWithoutProceduresNestedInput
  }

  export type AppointmentProcedureUncheckedUpdateWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentProcedureUncheckedUpdateManyWithoutNpiProviderInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureLabel?: NullableStringFieldUpdateOperationsInput | string | null
    fee?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    category?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    oralCavityArea?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumProcedureSourceFieldUpdateOperationsInput | $Enums.ProcedureSource
    comboKey?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineCreateManyClaimInput = {
    id?: number
    paymentId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
  }

  export type ClaimFileCreateManyClaimInput = {
    id?: number
    filename: string
    mimeType: string
    filePath?: string | null
  }

  export type ServiceLineUpdateWithoutClaimInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    payment?: PaymentUpdateOneWithoutServiceLinesNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineUncheckedUpdateWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineUncheckedUpdateManyWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
  }

  export type ClaimFileUpdateWithoutClaimInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClaimFileUncheckedUpdateWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ClaimFileUncheckedUpdateManyWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ServiceLineTransactionCreateManyServiceLineInput = {
    id?: number
    paymentId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineTransactionUpdateWithoutServiceLineInput = {
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payment?: PaymentUpdateOneRequiredWithoutServiceLineTransactionsNestedInput
  }

  export type ServiceLineTransactionUncheckedUpdateWithoutServiceLineInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PdfFileCreateManyGroupInput = {
    id?: number
    filename: string
    pdfData: Bytes
    uploadedAt?: Date | string
  }

  export type PdfFileUpdateWithoutGroupInput = {
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PdfFileUncheckedUpdateWithoutGroupInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PdfFileUncheckedUpdateManyWithoutGroupInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    pdfData?: BytesFieldUpdateOperationsInput | Bytes
    uploadedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionCreateManyPaymentInput = {
    id?: number
    serviceLineId: number
    transactionId?: string | null
    paidAmount: Decimal | DecimalJsLike | number | string
    adjustedAmount?: Decimal | DecimalJsLike | number | string
    method: $Enums.PaymentMethod
    receivedDate: Date | string
    payerName?: string | null
    notes?: string | null
    createdAt?: Date | string
  }

  export type ServiceLineCreateManyPaymentInput = {
    id?: number
    claimId?: number | null
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: string | null
    icn?: string | null
    paidCode?: string | null
    allowedAmount?: Decimal | DecimalJsLike | number | string | null
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue?: Decimal | DecimalJsLike | number | string
    status?: $Enums.ServiceLineStatus
  }

  export type CommissionBatchItemCreateManyPaymentInput = {
    id?: number
    commissionBatchId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type ServiceLineTransactionUpdateWithoutPaymentInput = {
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLine?: ServiceLineUpdateOneRequiredWithoutServiceLineTransactionsNestedInput
  }

  export type ServiceLineTransactionUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    serviceLineId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineTransactionUncheckedUpdateManyWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    serviceLineId?: IntFieldUpdateOperationsInput | number
    transactionId?: NullableStringFieldUpdateOperationsInput | string | null
    paidAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    adjustedAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    method?: EnumPaymentMethodFieldUpdateOperationsInput | $Enums.PaymentMethod
    receivedDate?: DateTimeFieldUpdateOperationsInput | Date | string
    payerName?: NullableStringFieldUpdateOperationsInput | string | null
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ServiceLineUpdateWithoutPaymentInput = {
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    claim?: ClaimUpdateOneWithoutServiceLinesNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutServiceLineNestedInput
  }

  export type ServiceLineUncheckedUpdateManyWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    procedureCode?: StringFieldUpdateOperationsInput | string
    procedureDate?: DateTimeFieldUpdateOperationsInput | Date | string
    quad?: NullableStringFieldUpdateOperationsInput | string | null
    arch?: NullableStringFieldUpdateOperationsInput | string | null
    toothNumber?: NullableStringFieldUpdateOperationsInput | string | null
    toothSurface?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    paidCode?: NullableStringFieldUpdateOperationsInput | string | null
    allowedAmount?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    totalBilled?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalPaid?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalAdjusted?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    totalDue?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    status?: EnumServiceLineStatusFieldUpdateOperationsInput | $Enums.ServiceLineStatus
  }

  export type CommissionBatchItemUpdateWithoutPaymentInput = {
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    commissionBatch?: CommissionBatchUpdateOneRequiredWithoutItemsNestedInput
  }

  export type CommissionBatchItemUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    commissionBatchId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    commissionBatchId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type CloudFolderCreateManyParentInput = {
    id?: number
    userId: number
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFileCreateManyFolderInput = {
    id?: number
    userId: number
    name: string
    mimeType?: string | null
    fileSize: bigint | number
    isComplete?: boolean
    totalChunks?: number | null
    diskPath?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CloudFolderUpdateWithoutParentInput = {
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    children?: CloudFolderUpdateManyWithoutParentNestedInput
    user?: UserUpdateOneRequiredWithoutCloudFoldersNestedInput
    files?: CloudFileUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateWithoutParentInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    children?: CloudFolderUncheckedUpdateManyWithoutParentNestedInput
    files?: CloudFileUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type CloudFolderUncheckedUpdateManyWithoutParentInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileUpdateWithoutFolderInput = {
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutCloudFilesNestedInput
    chunks?: CloudFileChunkUpdateManyWithoutFileNestedInput
  }

  export type CloudFileUncheckedUpdateWithoutFolderInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    chunks?: CloudFileChunkUncheckedUpdateManyWithoutFileNestedInput
  }

  export type CloudFileUncheckedUpdateManyWithoutFolderInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    mimeType?: NullableStringFieldUpdateOperationsInput | string | null
    fileSize?: BigIntFieldUpdateOperationsInput | bigint | number
    isComplete?: BoolFieldUpdateOperationsInput | boolean
    totalChunks?: NullableIntFieldUpdateOperationsInput | number | null
    diskPath?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkCreateManyFileInput = {
    id?: number
    seq: number
    data: Bytes
    createdAt?: Date | string
  }

  export type CloudFileChunkUpdateWithoutFileInput = {
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkUncheckedUpdateWithoutFileInput = {
    id?: IntFieldUpdateOperationsInput | number
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CloudFileChunkUncheckedUpdateManyWithoutFileInput = {
    id?: IntFieldUpdateOperationsInput | number
    seq?: IntFieldUpdateOperationsInput | number
    data?: BytesFieldUpdateOperationsInput | Bytes
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommissionBatchItemCreateManyCommissionBatchInput = {
    id?: number
    paymentId: number
    collectionAmount: Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUpdateWithoutCommissionBatchInput = {
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment?: PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInput
  }

  export type CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput = {
    id?: IntFieldUpdateOperationsInput | number
    paymentId?: IntFieldUpdateOperationsInput | number
    collectionAmount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}