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

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

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'
};

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.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.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.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>;
}

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',
    Staff: 'Staff',
    NpiProvider: 'NpiProvider',
    AppointmentProcedure: 'AppointmentProcedure',
    Claim: 'Claim',
    ServiceLine: 'ServiceLine',
    ClaimFile: 'ClaimFile',
    InsuranceCredential: 'InsuranceCredential',
    PdfGroup: 'PdfGroup',
    PdfFile: 'PdfFile',
    Payment: 'Payment',
    ServiceLineTransaction: 'ServiceLineTransaction',
    DatabaseBackup: 'DatabaseBackup',
    BackupDestination: 'BackupDestination',
    Notification: 'Notification',
    CloudFolder: 'CloudFolder',
    CloudFile: 'CloudFile',
    CloudFileChunk: 'CloudFileChunk',
    Communication: 'Communication',
    PatientDocument: 'PatientDocument'
  };

  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" | "staff" | "npiProvider" | "appointmentProcedure" | "claim" | "serviceLine" | "claimFile" | "insuranceCredential" | "pdfGroup" | "pdfFile" | "payment" | "serviceLineTransaction" | "databaseBackup" | "backupDestination" | "notification" | "cloudFolder" | "cloudFile" | "cloudFileChunk" | "communication" | "patientDocument"
      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
          }
        }
      }
      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
          }
        }
      }
      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
          }
        }
      }
      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
          }
        }
      }
    }
  } & {
    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
    staff?: StaffOmit
    npiProvider?: NpiProviderOmit
    appointmentProcedure?: AppointmentProcedureOmit
    claim?: ClaimOmit
    serviceLine?: ServiceLineOmit
    claimFile?: ClaimFileOmit
    insuranceCredential?: InsuranceCredentialOmit
    pdfGroup?: PdfGroupOmit
    pdfFile?: PdfFileOmit
    payment?: PaymentOmit
    serviceLineTransaction?: ServiceLineTransactionOmit
    databaseBackup?: DatabaseBackupOmit
    backupDestination?: BackupDestinationOmit
    notification?: NotificationOmit
    cloudFolder?: CloudFolderOmit
    cloudFile?: CloudFileOmit
    cloudFileChunk?: CloudFileChunkOmit
    communication?: CommunicationOmit
    patientDocument?: PatientDocumentOmit
  }

  /* 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
    updatedPayments: number
    backups: number
    backupDestinations: number
    notifications: number
    cloudFolders: number
    cloudFiles: number
    communications: 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
    updatedPayments?: boolean | UserCountOutputTypeCountUpdatedPaymentsArgs
    backups?: boolean | UserCountOutputTypeCountBackupsArgs
    backupDestinations?: boolean | UserCountOutputTypeCountBackupDestinationsArgs
    notifications?: boolean | UserCountOutputTypeCountNotificationsArgs
    cloudFolders?: boolean | UserCountOutputTypeCountCloudFoldersArgs
    cloudFiles?: boolean | UserCountOutputTypeCountCloudFilesArgs
    communications?: boolean | UserCountOutputTypeCountCommunicationsArgs
  }

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


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

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

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


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

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

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


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


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

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

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


  export type UserAvgAggregateInputType = {
    id?: true
  }

  export type UserSumAggregateInputType = {
    id?: true
  }

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

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

  export type UserCountAggregateInputType = {
    id?: true
    username?: true
    password?: 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
    _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
    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>
    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>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

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

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

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

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "username" | "password", 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>
    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>
    _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>[]
      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>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      username: string
      password: string
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

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

  type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | '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>
    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>
    /**
     * 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'>
  }
    

  // 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.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 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
    status: $Enums.PatientStatus | null
    userId: number | null
    createdAt: 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
    status: $Enums.PatientStatus | null
    userId: number | null
    createdAt: 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
    status: number
    userId: number
    createdAt: 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
    status?: true
    userId?: true
    createdAt?: 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
    status?: true
    userId?: true
    createdAt?: 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
    status?: true
    userId?: true
    createdAt?: 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
    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
    status: $Enums.PatientStatus
    userId: number
    createdAt: 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
    status?: boolean
    userId?: boolean
    createdAt?: 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>
    _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
    status?: boolean
    userId?: boolean
    createdAt?: 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
    status?: boolean
    userId?: boolean
    createdAt?: 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
    status?: boolean
    userId?: boolean
    createdAt?: 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" | "status" | "userId" | "createdAt", 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>
    _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>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      firstName: string
      lastName: string
      dateOfBirth: Date
      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
      status: $Enums.PatientStatus
      userId: number
      createdAt: 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>
    /**
     * 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 status: FieldRef<"Patient", 'PatientStatus'>
    readonly userId: FieldRef<"Patient", 'Int'>
    readonly createdAt: 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 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
    notes: string | null
    procedureCodeNotes: string | null
    status: string | 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
    notes: string | null
    procedureCodeNotes: string | null
    status: string | 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
    notes: number
    procedureCodeNotes: number
    status: 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
    notes?: true
    procedureCodeNotes?: true
    status?: 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
    notes?: true
    procedureCodeNotes?: true
    status?: 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
    notes?: true
    procedureCodeNotes?: true
    status?: 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
    notes: string | null
    procedureCodeNotes: string | null
    status: string
    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
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: 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>
    _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
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: 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
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: 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
    notes?: boolean
    procedureCodeNotes?: boolean
    status?: 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" | "notes" | "procedureCodeNotes" | "status" | "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>
    _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>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      userId: number
      staffId: number
      title: string
      date: Date
      startTime: string
      endTime: string
      type: string
      notes: string | null
      procedureCodeNotes: string | null
      status: string
      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>
    /**
     * 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 notes: FieldRef<"Appointment", 'String'>
    readonly procedureCodeNotes: FieldRef<"Appointment", 'String'>
    readonly status: FieldRef<"Appointment", 'String'>
    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 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 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>
  }, 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>
  }
  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>
    }
    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>
    /**
     * 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 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
    fee: Decimal | null
  }

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

  export type AppointmentProcedureMinAggregateOutputType = {
    id: number | null
    appointmentId: number | null
    patientId: 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
    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
    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
    fee?: true
  }

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

  export type AppointmentProcedureMinAggregateInputType = {
    id?: true
    appointmentId?: true
    patientId?: 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
    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
    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
    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
    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>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    patientId?: 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>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    appointmentId?: boolean
    patientId?: 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>
  }, ExtArgs["result"]["appointmentProcedure"]>

  export type AppointmentProcedureSelectScalar = {
    id?: boolean
    appointmentId?: boolean
    patientId?: 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" | "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>
  }
  export type AppointmentProcedureIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }
  export type AppointmentProcedureIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
  }

  export type $AppointmentProcedurePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentProcedure"
    objects: {
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      patient: Prisma.$PatientPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      appointmentId: number
      patientId: number
      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>
    /**
     * 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 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 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
  }

  export type ClaimSumAggregateOutputType = {
    id: number | null
    patientId: number | null
    appointmentId: number | null
    userId: number | null
    staffId: 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
  }

  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
  }

  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
    _all: number
  }


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

  export type ClaimSumAggregateInputType = {
    id?: true
    patientId?: true
    appointmentId?: true
    userId?: true
    staffId?: 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
  }

  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
  }

  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
    _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
    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
    _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
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<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
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<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
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<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
  }

  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", ExtArgs["result"]["claim"]>
  export type ClaimInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<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 | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
  }
  export type ClaimIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
    user?: boolean | Claim$userArgs<ExtArgs>
    staff?: boolean | Claim$staffArgs<ExtArgs>
  }

  export type $ClaimPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Claim"
    objects: {
      patient: Prisma.$PatientPayload<ExtArgs>
      appointment: Prisma.$AppointmentPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs> | null
      staff: Prisma.$StaffPayload<ExtArgs> | null
      serviceLines: Prisma.$ServiceLinePayload<ExtArgs>[]
      claimFiles: Prisma.$ClaimFilePayload<ExtArgs>[]
      payment: Prisma.$PaymentPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      patientId: number
      appointmentId: number
      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
    }, 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 AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<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>
    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'>
  }
    

  // 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.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.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
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
  }

  export type ServiceLineSumAggregateOutputType = {
    id: number | null
    claimId: number | null
    paymentId: number | 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
    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
    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
    totalBilled: number
    totalPaid: number
    totalAdjusted: number
    totalDue: number
    status: number
    _all: number
  }


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

  export type ServiceLineSumAggregateInputType = {
    id?: true
    claimId?: true
    paymentId?: 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
    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
    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
    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
    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
    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
    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
    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
    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" | "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
      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 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
  }

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

  export type ClaimFileCountAggregateOutputType = {
    id: number
    claimId: number
    filename: number
    mimeType: 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
  }

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

  export type ClaimFileCountAggregateInputType = {
    id?: true
    claimId?: true
    filename?: true
    mimeType?: 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
    _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
    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
    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
    claim?: boolean | ClaimDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["claimFile"]>

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

  export type ClaimFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "claimId" | "filename" | "mimeType", 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
    }, 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'>
  }
    

  // 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 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
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
  }

  export type PaymentSumAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: Decimal | null
  }

  export type PaymentMinAggregateOutputType = {
    id: number | null
    claimId: number | null
    patientId: number | null
    userId: number | null
    updatedById: number | null
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: 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
    totalBilled: Decimal | null
    totalPaid: Decimal | null
    totalAdjusted: Decimal | null
    totalDue: 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
    totalBilled: number
    totalPaid: number
    totalAdjusted: number
    totalDue: 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
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
  }

  export type PaymentSumAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
  }

  export type PaymentMinAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    status?: true
    notes?: true
    icn?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentMaxAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: true
    status?: true
    notes?: true
    icn?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentCountAggregateInputType = {
    id?: true
    claimId?: true
    patientId?: true
    userId?: true
    updatedById?: true
    totalBilled?: true
    totalPaid?: true
    totalAdjusted?: true
    totalDue?: 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
    totalBilled: Decimal
    totalPaid: Decimal
    totalAdjusted: Decimal
    totalDue: 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
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: 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>
    serviceLineTransactions?: boolean | Payment$serviceLineTransactionsArgs<ExtArgs>
    serviceLines?: boolean | Payment$serviceLinesArgs<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
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: 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>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: 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>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectScalar = {
    id?: boolean
    claimId?: boolean
    patientId?: boolean
    userId?: boolean
    updatedById?: boolean
    totalBilled?: boolean
    totalPaid?: boolean
    totalAdjusted?: boolean
    totalDue?: 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" | "totalBilled" | "totalPaid" | "totalAdjusted" | "totalDue" | "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>
    serviceLineTransactions?: boolean | Payment$serviceLineTransactionsArgs<ExtArgs>
    serviceLines?: boolean | Payment$serviceLinesArgs<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>
  }
  export type PaymentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    claim?: boolean | Payment$claimArgs<ExtArgs>
    patient?: boolean | PatientDefaultArgs<ExtArgs>
    updatedBy?: boolean | Payment$updatedByArgs<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
      serviceLineTransactions: Prisma.$ServiceLineTransactionPayload<ExtArgs>[]
      serviceLines: Prisma.$ServiceLinePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      claimId: number | null
      patientId: number
      userId: number
      updatedById: number | null
      totalBilled: Prisma.Decimal
      totalPaid: Prisma.Decimal
      totalAdjusted: Prisma.Decimal
      totalDue: 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>
    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>
    /**
     * 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 totalBilled: FieldRef<"Payment", 'Decimal'>
    readonly totalPaid: FieldRef<"Payment", 'Decimal'>
    readonly totalAdjusted: FieldRef<"Payment", 'Decimal'>
    readonly totalDue: 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.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 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 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
    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
    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
    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
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFileMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    mimeType?: true
    fileSize?: true
    folderId?: true
    isComplete?: true
    totalChunks?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CloudFileCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    mimeType?: true
    fileSize?: true
    folderId?: true
    isComplete?: true
    totalChunks?: 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
    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
    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
    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
    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
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CloudFileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "name" | "mimeType" | "fileSize" | "folderId" | "isComplete" | "totalChunks" | "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
      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 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
  }


  /**
   * 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'
  };

  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',
    status: 'status',
    userId: 'userId',
    createdAt: 'createdAt'
  };

  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',
    notes: 'notes',
    procedureCodeNotes: 'procedureCodeNotes',
    status: 'status',
    createdAt: 'createdAt',
    eligibilityStatus: 'eligibilityStatus'
  };

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


  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',
    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'
  };

  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',
    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'
  };

  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 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',
    totalBilled: 'totalBilled',
    totalPaid: 'totalPaid',
    totalAdjusted: 'totalAdjusted',
    totalDue: 'totalDue',
    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 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',
    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 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 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 '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 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * 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
    patients?: PatientListRelationFilter
    appointments?: AppointmentListRelationFilter
    staff?: StaffListRelationFilter
    npiProviders?: NpiProviderListRelationFilter
    claims?: ClaimListRelationFilter
    insuranceCredentials?: InsuranceCredentialListRelationFilter
    updatedPayments?: PaymentListRelationFilter
    backups?: DatabaseBackupListRelationFilter
    backupDestinations?: BackupDestinationListRelationFilter
    notifications?: NotificationListRelationFilter
    cloudFolders?: CloudFolderListRelationFilter
    cloudFiles?: CloudFileListRelationFilter
    communications?: CommunicationListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
    patients?: PatientOrderByRelationAggregateInput
    appointments?: AppointmentOrderByRelationAggregateInput
    staff?: StaffOrderByRelationAggregateInput
    npiProviders?: NpiProviderOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
    insuranceCredentials?: InsuranceCredentialOrderByRelationAggregateInput
    updatedPayments?: PaymentOrderByRelationAggregateInput
    backups?: DatabaseBackupOrderByRelationAggregateInput
    backupDestinations?: BackupDestinationOrderByRelationAggregateInput
    notifications?: NotificationOrderByRelationAggregateInput
    cloudFolders?: CloudFolderOrderByRelationAggregateInput
    cloudFiles?: CloudFileOrderByRelationAggregateInput
    communications?: CommunicationOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    username?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    password?: StringFilter<"User"> | string
    patients?: PatientListRelationFilter
    appointments?: AppointmentListRelationFilter
    staff?: StaffListRelationFilter
    npiProviders?: NpiProviderListRelationFilter
    claims?: ClaimListRelationFilter
    insuranceCredentials?: InsuranceCredentialListRelationFilter
    updatedPayments?: PaymentListRelationFilter
    backups?: DatabaseBackupListRelationFilter
    backupDestinations?: BackupDestinationListRelationFilter
    notifications?: NotificationListRelationFilter
    cloudFolders?: CloudFolderListRelationFilter
    cloudFiles?: CloudFileListRelationFilter
    communications?: CommunicationListRelationFilter
  }, "id" | "username">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    username?: SortOrder
    password?: 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
  }

  export type PatientWhereInput = {
    AND?: PatientWhereInput | PatientWhereInput[]
    OR?: PatientWhereInput[]
    NOT?: PatientWhereInput | PatientWhereInput[]
    id?: IntFilter<"Patient"> | number
    firstName?: StringFilter<"Patient"> | string
    lastName?: StringFilter<"Patient"> | string
    dateOfBirth?: DateTimeFilter<"Patient"> | Date | string
    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
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: DateTimeFilter<"Patient"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    appointments?: AppointmentListRelationFilter
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    groups?: PdfGroupListRelationFilter
    payment?: PaymentListRelationFilter
    communications?: CommunicationListRelationFilter
    documents?: PatientDocumentListRelationFilter
  }

  export type PatientOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: 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
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    appointments?: AppointmentOrderByRelationAggregateInput
    procedures?: AppointmentProcedureOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
    groups?: PdfGroupOrderByRelationAggregateInput
    payment?: PaymentOrderByRelationAggregateInput
    communications?: CommunicationOrderByRelationAggregateInput
    documents?: PatientDocumentOrderByRelationAggregateInput
  }

  export type PatientWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PatientWhereInput | PatientWhereInput[]
    OR?: PatientWhereInput[]
    NOT?: PatientWhereInput | PatientWhereInput[]
    firstName?: StringFilter<"Patient"> | string
    lastName?: StringFilter<"Patient"> | string
    dateOfBirth?: DateTimeFilter<"Patient"> | Date | string
    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
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: DateTimeFilter<"Patient"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    appointments?: AppointmentListRelationFilter
    procedures?: AppointmentProcedureListRelationFilter
    claims?: ClaimListRelationFilter
    groups?: PdfGroupListRelationFilter
    payment?: PaymentListRelationFilter
    communications?: CommunicationListRelationFilter
    documents?: PatientDocumentListRelationFilter
  }, "id">

  export type PatientOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    dateOfBirth?: 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
    status?: SortOrder
    userId?: SortOrder
    createdAt?: 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?: DateTimeWithAggregatesFilter<"Patient"> | Date | string
    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
    status?: EnumPatientStatusWithAggregatesFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntWithAggregatesFilter<"Patient"> | number
    createdAt?: 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
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    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
  }

  export type AppointmentOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    notes?: SortOrderInput | SortOrder
    procedureCodeNotes?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
    patient?: PatientOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    staff?: StaffOrderByWithRelationInput
    procedures?: AppointmentProcedureOrderByRelationAggregateInput
    claims?: ClaimOrderByRelationAggregateInput
  }

  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
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    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
  }, "id">

  export type AppointmentOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    notes?: SortOrderInput | SortOrder
    procedureCodeNotes?: SortOrderInput | SortOrder
    status?: 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
    notes?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableWithAggregatesFilter<"Appointment"> | string | null
    status?: StringWithAggregatesFilter<"Appointment"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    eligibilityStatus?: EnumPatientStatusWithAggregatesFilter<"Appointment"> | $Enums.PatientStatus
  }

  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>
  }

  export type NpiProviderOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    npiNumber?: SortOrder
    providerName?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  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>
  }, "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
    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>
  }

  export type AppointmentProcedureOrderByWithRelationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: 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
  }

  export type AppointmentProcedureWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    OR?: AppointmentProcedureWhereInput[]
    NOT?: AppointmentProcedureWhereInput | AppointmentProcedureWhereInput[]
    appointmentId?: IntFilter<"AppointmentProcedure"> | number
    patientId?: IntFilter<"AppointmentProcedure"> | number
    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>
  }, "id">

  export type AppointmentProcedureOrderByWithAggregationInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: 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
    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?: IntFilter<"Claim"> | number
    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
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    serviceLines?: ServiceLineListRelationFilter
    claimFiles?: ClaimFileListRelationFilter
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
  }

  export type ClaimOrderByWithRelationInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: 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
    patient?: PatientOrderByWithRelationInput
    appointment?: AppointmentOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    staff?: StaffOrderByWithRelationInput
    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?: IntFilter<"Claim"> | number
    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
    patient?: XOR<PatientScalarRelationFilter, PatientWhereInput>
    appointment?: XOR<AppointmentScalarRelationFilter, AppointmentWhereInput>
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    staff?: XOR<StaffNullableScalarRelationFilter, StaffWhereInput> | null
    serviceLines?: ServiceLineListRelationFilter
    claimFiles?: ClaimFileListRelationFilter
    payment?: XOR<PaymentNullableScalarRelationFilter, PaymentWhereInput> | null
  }, "id">

  export type ClaimOrderByWithAggregationInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: 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
    _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?: IntWithAggregatesFilter<"Claim"> | number
    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
  }

  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
    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
    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
    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
    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
    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
    claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
  }

  export type ClaimFileOrderByWithRelationInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: 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
    claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
  }, "id">

  export type ClaimFileOrderByWithAggregationInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: 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
  }

  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 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
    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
    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
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
    serviceLines?: ServiceLineListRelationFilter
  }

  export type PaymentOrderByWithRelationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    notes?: SortOrderInput | SortOrder
    icn?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    claim?: ClaimOrderByWithRelationInput
    patient?: PatientOrderByWithRelationInput
    updatedBy?: UserOrderByWithRelationInput
    serviceLineTransactions?: ServiceLineTransactionOrderByRelationAggregateInput
    serviceLines?: ServiceLineOrderByRelationAggregateInput
  }

  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
    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
    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
    serviceLineTransactions?: ServiceLineTransactionListRelationFilter
    serviceLines?: ServiceLineListRelationFilter
  }, "id" | "claimId">

  export type PaymentOrderByWithAggregationInput = {
    id?: SortOrder
    claimId?: SortOrderInput | SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrderInput | SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: 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
    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
    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 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
    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
    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
    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
    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
    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 UserCreateInput = {
    username: string
    password: string
    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
  }

  export type UserUncheckedCreateInput = {
    id?: number
    username: string
    password: string
    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
  }

  export type UserUpdateInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    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
  }

  export type UserUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    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
  }

  export type UserCreateManyInput = {
    id?: number
    username: string
    password: string
  }

  export type UserUpdateManyMutationInput = {
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
  }

  export type PatientCreateInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientUpdateInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  export type PatientCreateManyInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
  }

  export type PatientUpdateManyMutationInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentCreateManyInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
  }

  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
  }

  export type NpiProviderUncheckedCreateInput = {
    id?: number
    userId: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
  }

  export type NpiProviderUpdateInput = {
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutNpiProvidersNestedInput
  }

  export type NpiProviderUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    userId?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  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
  }

  export type AppointmentProcedureUncheckedCreateInput = {
    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 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
  }

  export type AppointmentProcedureUncheckedUpdateInput = {
    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 AppointmentProcedureCreateManyInput = {
    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 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
    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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateInput = {
    id?: number
    patientId: number
    appointmentId: 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
    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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimCreateManyInput = {
    id?: number
    patientId: number
    appointmentId: 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
  }

  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
  }

  export type ClaimUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
  }

  export type ServiceLineCreateInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: 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
    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
    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
    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
    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
    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
    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
    claim: ClaimCreateNestedOneWithoutClaimFilesInput
  }

  export type ClaimFileUncheckedCreateInput = {
    id?: number
    claimId: number
    filename: string
    mimeType: string
  }

  export type ClaimFileUpdateInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    claim?: ClaimUpdateOneRequiredWithoutClaimFilesNestedInput
  }

  export type ClaimFileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
  }

  export type ClaimFileCreateManyInput = {
    id?: number
    claimId: number
    filename: string
    mimeType: string
  }

  export type ClaimFileUpdateManyMutationInput = {
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
  }

  export type ClaimFileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
  }

  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 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
    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
  }

  export type PaymentUncheckedCreateInput = {
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
  }

  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
    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
  }

  export type PaymentUncheckedUpdateInput = {
    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
    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 PaymentCreateManyInput = {
    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
    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
    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
    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?: 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 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
    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
    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
    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
    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
    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
    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
    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 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 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 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 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 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 UserCountOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
  }

  export type UserAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    username?: SortOrder
    password?: 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 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 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 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 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
    status?: SortOrder
    userId?: SortOrder
    createdAt?: 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
    status?: SortOrder
    userId?: SortOrder
    createdAt?: 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
    status?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type PatientSumOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
  }

  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 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 PatientScalarRelationFilter = {
    is?: PatientWhereInput
    isNot?: PatientWhereInput
  }

  export type StaffNullableScalarRelationFilter = {
    is?: StaffWhereInput | null
    isNot?: StaffWhereInput | null
  }

  export type AppointmentCountOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: SortOrder
    title?: SortOrder
    date?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    type?: SortOrder
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: 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
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: 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
    notes?: SortOrder
    procedureCodeNotes?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    eligibilityStatus?: SortOrder
  }

  export type AppointmentSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    staffId?: 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 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 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 AppointmentScalarRelationFilter = {
    is?: AppointmentWhereInput
    isNot?: AppointmentWhereInput
  }

  export type AppointmentProcedureCountOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: 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
    fee?: SortOrder
  }

  export type AppointmentProcedureMaxOrderByAggregateInput = {
    id?: SortOrder
    appointmentId?: SortOrder
    patientId?: 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
    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
    fee?: SortOrder
  }

  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 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
  }

  export type ClaimAvgOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: 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
  }

  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
  }

  export type ClaimSumOrderByAggregateInput = {
    id?: SortOrder
    patientId?: SortOrder
    appointmentId?: SortOrder
    userId?: SortOrder
    staffId?: 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 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 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
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
  }

  export type ServiceLineAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: 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
    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
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
  }

  export type ServiceLineSumOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    paymentId?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: 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 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
  }

  export type ClaimFileAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
  }

  export type ClaimFileMaxOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: SortOrder
  }

  export type ClaimFileMinOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    filename?: SortOrder
    mimeType?: 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 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 PaymentCountOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentAvgOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
  }

  export type PaymentMaxOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentMinOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: SortOrder
    status?: SortOrder
    notes?: SortOrder
    icn?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentSumOrderByAggregateInput = {
    id?: SortOrder
    claimId?: SortOrder
    patientId?: SortOrder
    userId?: SortOrder
    updatedById?: SortOrder
    totalBilled?: SortOrder
    totalPaid?: SortOrder
    totalAdjusted?: SortOrder
    totalDue?: 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 BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  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 BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  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 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
    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
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CloudFileMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    mimeType?: SortOrder
    fileSize?: SortOrder
    folderId?: SortOrder
    isComplete?: SortOrder
    totalChunks?: 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 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 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 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 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 StringFieldUpdateOperationsInput = {
    set?: string
  }

  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 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 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 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 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 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 DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type EnumPatientStatusFieldUpdateOperationsInput = {
    set?: $Enums.PatientStatus
  }

  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 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 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 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 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 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 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 UserUpdateOneRequiredWithoutNpiProvidersNestedInput = {
    create?: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
    connectOrCreate?: UserCreateOrConnectWithoutNpiProvidersInput
    upsert?: UserUpsertWithoutNpiProvidersInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutNpiProvidersInput, UserUpdateWithoutNpiProvidersInput>, UserUncheckedUpdateWithoutNpiProvidersInput>
  }

  export type AppointmentCreateNestedOneWithoutProceduresInput = {
    create?: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutProceduresInput
    connect?: AppointmentWhereUniqueInput
  }

  export type PatientCreateNestedOneWithoutProceduresInput = {
    create?: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
    connectOrCreate?: PatientCreateOrConnectWithoutProceduresInput
    connect?: PatientWhereUniqueInput
  }

  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 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 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 AppointmentUpdateOneRequiredWithoutClaimsNestedInput = {
    create?: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutClaimsInput
    upsert?: AppointmentUpsertWithoutClaimsInput
    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 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 NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  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 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 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 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 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 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 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 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 BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  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 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 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 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 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 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 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 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 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 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 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 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 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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$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 PatientCreateWithoutUserInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutUserInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  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
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  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
  }

  export type NpiProviderUncheckedCreateWithoutUserInput = {
    id?: number
    npiNumber: string
    providerName: string
    createdAt?: Date | string
  }

  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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutUserInput = {
    id?: number
    patientId: number
    appointmentId: 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
    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 PaymentCreateWithoutUpdatedByInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: Decimal | DecimalJsLike | number | string
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutUpdatedByInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: 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 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
    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
    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 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?: DateTimeFilter<"Patient"> | Date | string
    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
    status?: EnumPatientStatusFilter<"Patient"> | $Enums.PatientStatus
    userId?: IntFilter<"Patient"> | number
    createdAt?: 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
    notes?: StringNullableFilter<"Appointment"> | string | null
    procedureCodeNotes?: StringNullableFilter<"Appointment"> | string | null
    status?: StringFilter<"Appointment"> | string
    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?: IntFilter<"Claim"> | number
    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
  }

  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 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
    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
    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
    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 UserCreateWithoutPatientsInput = {
    username: string
    password: string
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPatientsInput = {
    id?: number
    username: string
    password: string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPatientsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPatientsInput, UserUncheckedCreateWithoutPatientsInput>
  }

  export type AppointmentCreateWithoutPatientInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutPatientInput = {
    id?: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  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
  }

  export type AppointmentProcedureUncheckedCreateWithoutPatientInput = {
    id?: number
    appointmentId: 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 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
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutPatientInput = {
    id?: number
    appointmentId: 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
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutPatientInput = {
    id?: number
    claimId?: number | null
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
  }

  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 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
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPatientsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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
    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 PatientCreateWithoutAppointmentsInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutAppointmentsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutAppointmentsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutAppointmentsInput, PatientUncheckedCreateWithoutAppointmentsInput>
  }

  export type UserCreateWithoutAppointmentsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
  }

  export type AppointmentProcedureUncheckedCreateWithoutAppointmentInput = {
    id?: 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 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
    patient: PatientCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    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
    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 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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutAppointmentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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 UserCreateWithoutStaffInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutStaffInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutStaffInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutStaffInput, UserUncheckedCreateWithoutStaffInput>
  }

  export type AppointmentCreateWithoutStaffInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutStaffInput = {
    id?: number
    patientId: number
    userId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutStaffInput = {
    id?: number
    patientId: number
    appointmentId: number
    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
    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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutNpiProvidersInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutNpiProvidersInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutNpiProvidersInput, UserUncheckedCreateWithoutNpiProvidersInput>
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutNpiProvidersInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentCreateWithoutProceduresInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    claims?: ClaimCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutProceduresInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    claims?: ClaimUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutProceduresInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutProceduresInput, AppointmentUncheckedCreateWithoutProceduresInput>
  }

  export type PatientCreateWithoutProceduresInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutProceduresInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutProceduresInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutProceduresInput, PatientUncheckedCreateWithoutProceduresInput>
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutProceduresInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  export type PatientCreateWithoutClaimsInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutClaimsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutClaimsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutClaimsInput, PatientUncheckedCreateWithoutClaimsInput>
  }

  export type AppointmentCreateWithoutClaimsInput = {
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    patient: PatientCreateNestedOneWithoutAppointmentsInput
    user: UserCreateNestedOneWithoutAppointmentsInput
    staff?: StaffCreateNestedOneWithoutAppointmentsInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutClaimsInput = {
    id?: number
    patientId: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutClaimsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutClaimsInput, AppointmentUncheckedCreateWithoutClaimsInput>
  }

  export type UserCreateWithoutClaimsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutClaimsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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 ServiceLineCreateWithoutClaimInput = {
    procedureCode: string
    procedureDate: Date | string
    quad?: string | null
    arch?: string | null
    toothNumber?: string | null
    toothSurface?: 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
    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
  }

  export type ClaimFileUncheckedCreateWithoutClaimInput = {
    id?: number
    filename: string
    mimeType: string
  }

  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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutClaimInput = {
    id?: number
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
  }

  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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutClaimsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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 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
    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
  }

  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
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    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
    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 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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutServiceLinesInput = {
    id?: number
    patientId: number
    appointmentId: 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
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    claim?: ClaimCreateNestedOneWithoutPaymentInput
    patient: PatientCreateNestedOneWithoutPaymentInput
    updatedBy?: UserCreateNestedOneWithoutUpdatedPaymentsInput
    serviceLineTransactions?: ServiceLineTransactionCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutServiceLinesInput = {
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedCreateNestedManyWithoutPaymentInput
  }

  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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutServiceLinesInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    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
    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
  }

  export type PaymentUncheckedUpdateWithoutServiceLinesInput = {
    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
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLineTransactions?: ServiceLineTransactionUncheckedUpdateManyWithoutPaymentNestedInput
  }

  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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    payment?: PaymentCreateNestedOneWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutClaimFilesInput = {
    id?: number
    patientId: number
    appointmentId: 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
    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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutClaimFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type UserCreateWithoutInsuranceCredentialsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutInsuranceCredentialsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutInsuranceCredentialsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PatientCreateWithoutGroupsInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutGroupsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutGroupsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  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
    patient: PatientCreateNestedOneWithoutClaimsInput
    appointment: AppointmentCreateNestedOneWithoutClaimsInput
    user?: UserCreateNestedOneWithoutClaimsInput
    staff?: StaffCreateNestedOneWithoutClaimsInput
    serviceLines?: ServiceLineCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileCreateNestedManyWithoutClaimInput
  }

  export type ClaimUncheckedCreateWithoutPaymentInput = {
    id?: number
    patientId: number
    appointmentId: 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
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutClaimInput
    claimFiles?: ClaimFileUncheckedCreateNestedManyWithoutClaimInput
  }

  export type ClaimCreateOrConnectWithoutPaymentInput = {
    where: ClaimWhereUniqueInput
    create: XOR<ClaimCreateWithoutPaymentInput, ClaimUncheckedCreateWithoutPaymentInput>
  }

  export type PatientCreateWithoutPaymentInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutPaymentInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutPaymentInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutPaymentInput, PatientUncheckedCreateWithoutPaymentInput>
  }

  export type UserCreateWithoutUpdatedPaymentsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutUpdatedPaymentsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutUpdatedPaymentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutUpdatedPaymentsInput, UserUncheckedCreateWithoutUpdatedPaymentsInput>
  }

  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
    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
    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 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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutPaymentInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutUpdatedPaymentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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 PaymentCreateWithoutServiceLineTransactionsInput = {
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: 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
    serviceLines?: ServiceLineCreateNestedManyWithoutPaymentInput
  }

  export type PaymentUncheckedCreateWithoutServiceLineTransactionsInput = {
    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
    status?: $Enums.PaymentStatus
    notes?: string | null
    icn?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    serviceLines?: ServiceLineUncheckedCreateNestedManyWithoutPaymentInput
  }

  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
    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
    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
    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
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutServiceLineTransactionsInput = {
    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
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutPaymentNestedInput
  }

  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
    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
    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
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutBackupsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutBackupsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutBackupDestinationsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutBackupDestinationsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutBackupDestinationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutNotificationsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutNotificationsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutNotificationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCloudFoldersInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    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
    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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCloudFoldersInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    communications?: CommunicationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCloudFilesInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutUserInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    communications?: CommunicationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCloudFilesInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutUserNestedInput
  }

  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
    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
    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
    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
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PatientCreateWithoutCommunicationsInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutCommunicationsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    documents?: PatientDocumentUncheckedCreateNestedManyWithoutPatientInput
  }

  export type PatientCreateOrConnectWithoutCommunicationsInput = {
    where: PatientWhereUniqueInput
    create: XOR<PatientCreateWithoutCommunicationsInput, PatientUncheckedCreateWithoutCommunicationsInput>
  }

  export type UserCreateWithoutCommunicationsInput = {
    username: string
    password: string
    patients?: PatientCreateNestedManyWithoutUserInput
    appointments?: AppointmentCreateNestedManyWithoutUserInput
    staff?: StaffCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderCreateNestedManyWithoutUserInput
    claims?: ClaimCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCommunicationsInput = {
    id?: number
    username: string
    password: string
    patients?: PatientUncheckedCreateNestedManyWithoutUserInput
    appointments?: AppointmentUncheckedCreateNestedManyWithoutUserInput
    staff?: StaffUncheckedCreateNestedManyWithoutUserInput
    npiProviders?: NpiProviderUncheckedCreateNestedManyWithoutUserInput
    claims?: ClaimUncheckedCreateNestedManyWithoutUserInput
    insuranceCredentials?: InsuranceCredentialUncheckedCreateNestedManyWithoutUserInput
    updatedPayments?: PaymentUncheckedCreateNestedManyWithoutUpdatedByInput
    backups?: DatabaseBackupUncheckedCreateNestedManyWithoutUserInput
    backupDestinations?: BackupDestinationUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    cloudFolders?: CloudFolderUncheckedCreateNestedManyWithoutUserInput
    cloudFiles?: CloudFileUncheckedCreateNestedManyWithoutUserInput
  }

  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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutCommunicationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  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
    patients?: PatientUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUpdateManyWithoutUserNestedInput
    staff?: StaffUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUpdateManyWithoutUserNestedInput
    claims?: ClaimUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCommunicationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    username?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    patients?: PatientUncheckedUpdateManyWithoutUserNestedInput
    appointments?: AppointmentUncheckedUpdateManyWithoutUserNestedInput
    staff?: StaffUncheckedUpdateManyWithoutUserNestedInput
    npiProviders?: NpiProviderUncheckedUpdateManyWithoutUserNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutUserNestedInput
    insuranceCredentials?: InsuranceCredentialUncheckedUpdateManyWithoutUserNestedInput
    updatedPayments?: PaymentUncheckedUpdateManyWithoutUpdatedByNestedInput
    backups?: DatabaseBackupUncheckedUpdateManyWithoutUserNestedInput
    backupDestinations?: BackupDestinationUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    cloudFolders?: CloudFolderUncheckedUpdateManyWithoutUserNestedInput
    cloudFiles?: CloudFileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PatientCreateWithoutDocumentsInput = {
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutPatientsInput
    appointments?: AppointmentCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureCreateNestedManyWithoutPatientInput
    claims?: ClaimCreateNestedManyWithoutPatientInput
    groups?: PdfGroupCreateNestedManyWithoutPatientInput
    payment?: PaymentCreateNestedManyWithoutPatientInput
    communications?: CommunicationCreateNestedManyWithoutPatientInput
  }

  export type PatientUncheckedCreateWithoutDocumentsInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    userId: number
    createdAt?: Date | string
    appointments?: AppointmentUncheckedCreateNestedManyWithoutPatientInput
    procedures?: AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput
    claims?: ClaimUncheckedCreateNestedManyWithoutPatientInput
    groups?: PdfGroupUncheckedCreateNestedManyWithoutPatientInput
    payment?: PaymentUncheckedCreateNestedManyWithoutPatientInput
    communications?: CommunicationUncheckedCreateNestedManyWithoutPatientInput
  }

  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?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPatientsNestedInput
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutDocumentsInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    userId?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
  }

  export type PatientCreateManyUserInput = {
    id?: number
    firstName: string
    lastName: string
    dateOfBirth: Date | string
    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
    status?: $Enums.PatientStatus
    createdAt?: Date | string
  }

  export type AppointmentCreateManyUserInput = {
    id?: number
    patientId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    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
    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
  }

  export type InsuranceCredentialCreateManyUserInput = {
    id?: number
    siteKey: string
    username: string
    password: string
  }

  export type PaymentCreateManyUpdatedByInput = {
    id?: number
    claimId?: number | null
    patientId: number
    userId: number
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: 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
    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 PatientUpdateWithoutUserInput = {
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutPatientNestedInput
    claims?: ClaimUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUpdateManyWithoutPatientNestedInput
    payment?: PaymentUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointments?: AppointmentUncheckedUpdateManyWithoutPatientNestedInput
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutPatientNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutPatientNestedInput
    groups?: PdfGroupUncheckedUpdateManyWithoutPatientNestedInput
    payment?: PaymentUncheckedUpdateManyWithoutPatientNestedInput
    communications?: CommunicationUncheckedUpdateManyWithoutPatientNestedInput
    documents?: PatientDocumentUncheckedUpdateManyWithoutPatientNestedInput
  }

  export type PatientUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    dateOfBirth?: DateTimeFieldUpdateOperationsInput | Date | string
    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
    status?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUpdateWithoutUserInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    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
  }

  export type NpiProviderUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    npiNumber?: StringFieldUpdateOperationsInput | string
    providerName?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutUserInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
  }

  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 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
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    patient?: PatientUpdateOneRequiredWithoutPaymentNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutUpdatedByInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    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
    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 PaymentUncheckedUpdateManyWithoutUpdatedByInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    patientId?: IntFieldUpdateOperationsInput | number
    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
    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
    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
    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
    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 AppointmentCreateManyPatientInput = {
    id?: number
    userId: number
    staffId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type AppointmentProcedureCreateManyPatientInput = {
    id?: number
    appointmentId: 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 ClaimCreateManyPatientInput = {
    id?: number
    appointmentId: 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
  }

  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
    totalBilled: Decimal | DecimalJsLike | number | string
    totalPaid?: Decimal | DecimalJsLike | number | string
    totalAdjusted?: Decimal | DecimalJsLike | number | string
    totalDue: 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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    staff?: StaffUpdateOneWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    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
  }

  export type AppointmentProcedureUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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 AppointmentProcedureUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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 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
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    appointmentId?: 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
  }

  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
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    icn?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    claim?: ClaimUpdateOneWithoutPaymentNestedInput
    updatedBy?: UserUpdateOneWithoutUpdatedPaymentsNestedInput
    serviceLineTransactions?: ServiceLineTransactionUpdateManyWithoutPaymentNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutPaymentNestedInput
  }

  export type PaymentUncheckedUpdateWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    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
    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 PaymentUncheckedUpdateManyWithoutPatientInput = {
    id?: IntFieldUpdateOperationsInput | number
    claimId?: NullableIntFieldUpdateOperationsInput | number | null
    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
    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
    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
  }

  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
  }

  export type AppointmentProcedureUncheckedUpdateWithoutAppointmentInput = {
    id?: 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 AppointmentProcedureUncheckedUpdateManyWithoutAppointmentInput = {
    id?: 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 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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    staff?: StaffUpdateOneWithoutClaimsNestedInput
    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
    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
  }

  export type AppointmentCreateManyStaffInput = {
    id?: number
    patientId: number
    userId: number
    title: string
    date: Date | string
    startTime: string
    endTime: string
    type: string
    notes?: string | null
    procedureCodeNotes?: string | null
    status?: string
    createdAt?: Date | string
    eligibilityStatus?: $Enums.PatientStatus
  }

  export type ClaimCreateManyStaffInput = {
    id?: number
    patientId: number
    appointmentId: number
    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
  }

  export type AppointmentUpdateWithoutStaffInput = {
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    patient?: PatientUpdateOneRequiredWithoutAppointmentsNestedInput
    user?: UserUpdateOneRequiredWithoutAppointmentsNestedInput
    procedures?: AppointmentProcedureUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    eligibilityStatus?: EnumPatientStatusFieldUpdateOperationsInput | $Enums.PatientStatus
    procedures?: AppointmentProcedureUncheckedUpdateManyWithoutAppointmentNestedInput
    claims?: ClaimUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  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
    notes?: NullableStringFieldUpdateOperationsInput | string | null
    procedureCodeNotes?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    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
    patient?: PatientUpdateOneRequiredWithoutClaimsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutClaimsNestedInput
    user?: UserUpdateOneWithoutClaimsNestedInput
    serviceLines?: ServiceLineUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUpdateManyWithoutClaimNestedInput
    payment?: PaymentUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    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
    serviceLines?: ServiceLineUncheckedUpdateManyWithoutClaimNestedInput
    claimFiles?: ClaimFileUncheckedUpdateManyWithoutClaimNestedInput
    payment?: PaymentUncheckedUpdateOneWithoutClaimNestedInput
  }

  export type ClaimUncheckedUpdateManyWithoutStaffInput = {
    id?: IntFieldUpdateOperationsInput | number
    patientId?: IntFieldUpdateOperationsInput | number
    appointmentId?: IntFieldUpdateOperationsInput | number
    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
  }

  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
    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
  }

  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
    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
    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
    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
  }

  export type ClaimFileUncheckedUpdateWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
  }

  export type ClaimFileUncheckedUpdateManyWithoutClaimInput = {
    id?: IntFieldUpdateOperationsInput | number
    filename?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
  }

  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
    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 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
    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
    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
    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 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
    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
    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
    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
    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
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}