FrenoCorp/node_modules/.prisma/client/index.d.ts

/**
 * Client
**/

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

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


/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model Account
 * 
 */
export type Account = $Result.DefaultSelection<Prisma.$AccountPayload>
/**
 * Model Session
 * 
 */
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
/**
 * Model FamilyGroup
 * 
 */
export type FamilyGroup = $Result.DefaultSelection<Prisma.$FamilyGroupPayload>
/**
 * Model FamilyGroupMember
 * 
 */
export type FamilyGroupMember = $Result.DefaultSelection<Prisma.$FamilyGroupMemberPayload>
/**
 * Model Subscription
 * 
 */
export type Subscription = $Result.DefaultSelection<Prisma.$SubscriptionPayload>
/**
 * Model WatchlistItem
 * 
 */
export type WatchlistItem = $Result.DefaultSelection<Prisma.$WatchlistItemPayload>
/**
 * Model Exposure
 * 
 */
export type Exposure = $Result.DefaultSelection<Prisma.$ExposurePayload>
/**
 * Model Alert
 * 
 */
export type Alert = $Result.DefaultSelection<Prisma.$AlertPayload>
/**
 * Model VoiceEnrollment
 * 
 */
export type VoiceEnrollment = $Result.DefaultSelection<Prisma.$VoiceEnrollmentPayload>
/**
 * Model VoiceAnalysis
 * 
 */
export type VoiceAnalysis = $Result.DefaultSelection<Prisma.$VoiceAnalysisPayload>
/**
 * Model SpamFeedback
 * 
 */
export type SpamFeedback = $Result.DefaultSelection<Prisma.$SpamFeedbackPayload>
/**
 * Model SpamRule
 * 
 */
export type SpamRule = $Result.DefaultSelection<Prisma.$SpamRulePayload>
/**
 * Model AuditLog
 * 
 */
export type AuditLog = $Result.DefaultSelection<Prisma.$AuditLogPayload>
/**
 * Model KPISnapshot
 * 
 */
export type KPISnapshot = $Result.DefaultSelection<Prisma.$KPISnapshotPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const UserRole: {
  user: 'user',
  family_admin: 'family_admin',
  family_member: 'family_member',
  support: 'support'
};

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


export const FamilyMemberRole: {
  owner: 'owner',
  admin: 'admin',
  member: 'member'
};

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


export const SubscriptionTier: {
  basic: 'basic',
  plus: 'plus',
  premium: 'premium'
};

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


export const SubscriptionStatus: {
  active: 'active',
  past_due: 'past_due',
  canceled: 'canceled',
  unpaid: 'unpaid',
  trialing: 'trialing'
};

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


export const WatchlistType: {
  email: 'email',
  phoneNumber: 'phoneNumber',
  ssn: 'ssn',
  address: 'address',
  domain: 'domain'
};

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


export const ExposureSource: {
  hibp: 'hibp',
  securityTrails: 'securityTrails',
  censys: 'censys',
  darkWebForum: 'darkWebForum',
  shodan: 'shodan',
  honeypot: 'honeypot'
};

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


export const ExposureSeverity: {
  info: 'info',
  warning: 'warning',
  critical: 'critical'
};

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


export const AlertType: {
  exposure_detected: 'exposure_detected',
  exposure_resolved: 'exposure_resolved',
  scan_complete: 'scan_complete',
  subscription_changed: 'subscription_changed',
  system_warning: 'system_warning'
};

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


export const AlertSeverity: {
  info: 'info',
  warning: 'warning',
  critical: 'critical'
};

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


export const AlertChannel: {
  email: 'email',
  push: 'push',
  sms: 'sms'
};

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


export const FeedbackType: {
  initial_detection: 'initial_detection',
  user_confirmation: 'user_confirmation',
  user_rejection: 'user_rejection',
  auto_learned: 'auto_learned'
};

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


export const RuleType: {
  phoneNumber: 'phoneNumber',
  areaCode: 'areaCode',
  prefix: 'prefix',
  pattern: 'pattern',
  reputation: 'reputation'
};

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


export const RuleAction: {
  block: 'block',
  flag: 'flag',
  allow: 'allow',
  challenge: 'challenge'
};

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

}

export type UserRole = $Enums.UserRole

export const UserRole: typeof $Enums.UserRole

export type FamilyMemberRole = $Enums.FamilyMemberRole

export const FamilyMemberRole: typeof $Enums.FamilyMemberRole

export type SubscriptionTier = $Enums.SubscriptionTier

export const SubscriptionTier: typeof $Enums.SubscriptionTier

export type SubscriptionStatus = $Enums.SubscriptionStatus

export const SubscriptionStatus: typeof $Enums.SubscriptionStatus

export type WatchlistType = $Enums.WatchlistType

export const WatchlistType: typeof $Enums.WatchlistType

export type ExposureSource = $Enums.ExposureSource

export const ExposureSource: typeof $Enums.ExposureSource

export type ExposureSeverity = $Enums.ExposureSeverity

export const ExposureSeverity: typeof $Enums.ExposureSeverity

export type AlertType = $Enums.AlertType

export const AlertType: typeof $Enums.AlertType

export type AlertSeverity = $Enums.AlertSeverity

export const AlertSeverity: typeof $Enums.AlertSeverity

export type AlertChannel = $Enums.AlertChannel

export const AlertChannel: typeof $Enums.AlertChannel

export type FeedbackType = $Enums.FeedbackType

export const FeedbackType: typeof $Enums.FeedbackType

export type RuleType = $Enums.RuleType

export const RuleType: typeof $Enums.RuleType

export type RuleAction = $Enums.RuleAction

export const RuleAction: typeof $Enums.RuleAction

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

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

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

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

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

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

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

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

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

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


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

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


  $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs>

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

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

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

  /**
   * `prisma.familyGroup`: Exposes CRUD operations for the **FamilyGroup** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FamilyGroups
    * const familyGroups = await prisma.familyGroup.findMany()
    * ```
    */
  get familyGroup(): Prisma.FamilyGroupDelegate<ExtArgs>;

  /**
   * `prisma.familyGroupMember`: Exposes CRUD operations for the **FamilyGroupMember** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FamilyGroupMembers
    * const familyGroupMembers = await prisma.familyGroupMember.findMany()
    * ```
    */
  get familyGroupMember(): Prisma.FamilyGroupMemberDelegate<ExtArgs>;

  /**
   * `prisma.subscription`: Exposes CRUD operations for the **Subscription** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Subscriptions
    * const subscriptions = await prisma.subscription.findMany()
    * ```
    */
  get subscription(): Prisma.SubscriptionDelegate<ExtArgs>;

  /**
   * `prisma.watchlistItem`: Exposes CRUD operations for the **WatchlistItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more WatchlistItems
    * const watchlistItems = await prisma.watchlistItem.findMany()
    * ```
    */
  get watchlistItem(): Prisma.WatchlistItemDelegate<ExtArgs>;

  /**
   * `prisma.exposure`: Exposes CRUD operations for the **Exposure** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Exposures
    * const exposures = await prisma.exposure.findMany()
    * ```
    */
  get exposure(): Prisma.ExposureDelegate<ExtArgs>;

  /**
   * `prisma.alert`: Exposes CRUD operations for the **Alert** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Alerts
    * const alerts = await prisma.alert.findMany()
    * ```
    */
  get alert(): Prisma.AlertDelegate<ExtArgs>;

  /**
   * `prisma.voiceEnrollment`: Exposes CRUD operations for the **VoiceEnrollment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more VoiceEnrollments
    * const voiceEnrollments = await prisma.voiceEnrollment.findMany()
    * ```
    */
  get voiceEnrollment(): Prisma.VoiceEnrollmentDelegate<ExtArgs>;

  /**
   * `prisma.voiceAnalysis`: Exposes CRUD operations for the **VoiceAnalysis** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more VoiceAnalyses
    * const voiceAnalyses = await prisma.voiceAnalysis.findMany()
    * ```
    */
  get voiceAnalysis(): Prisma.VoiceAnalysisDelegate<ExtArgs>;

  /**
   * `prisma.spamFeedback`: Exposes CRUD operations for the **SpamFeedback** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SpamFeedbacks
    * const spamFeedbacks = await prisma.spamFeedback.findMany()
    * ```
    */
  get spamFeedback(): Prisma.SpamFeedbackDelegate<ExtArgs>;

  /**
   * `prisma.spamRule`: Exposes CRUD operations for the **SpamRule** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SpamRules
    * const spamRules = await prisma.spamRule.findMany()
    * ```
    */
  get spamRule(): Prisma.SpamRuleDelegate<ExtArgs>;

  /**
   * `prisma.auditLog`: Exposes CRUD operations for the **AuditLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AuditLogs
    * const auditLogs = await prisma.auditLog.findMany()
    * ```
    */
  get auditLog(): Prisma.AuditLogDelegate<ExtArgs>;

  /**
   * `prisma.kPISnapshot`: Exposes CRUD operations for the **KPISnapshot** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more KPISnapshots
    * const kPISnapshots = await prisma.kPISnapshot.findMany()
    * ```
    */
  get kPISnapshot(): Prisma.KPISnapshotDelegate<ExtArgs>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

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

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

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

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

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

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


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    User: 'User',
    Account: 'Account',
    Session: 'Session',
    FamilyGroup: 'FamilyGroup',
    FamilyGroupMember: 'FamilyGroupMember',
    Subscription: 'Subscription',
    WatchlistItem: 'WatchlistItem',
    Exposure: 'Exposure',
    Alert: 'Alert',
    VoiceEnrollment: 'VoiceEnrollment',
    VoiceAnalysis: 'VoiceAnalysis',
    SpamFeedback: 'SpamFeedback',
    SpamRule: 'SpamRule',
    AuditLog: 'AuditLog',
    KPISnapshot: 'KPISnapshot'
  };

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


  export type Datasources = {
    db?: Datasource
  }

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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "user" | "account" | "session" | "familyGroup" | "familyGroupMember" | "subscription" | "watchlistItem" | "exposure" | "alert" | "voiceEnrollment" | "voiceAnalysis" | "spamFeedback" | "spamRule" | "auditLog" | "kPISnapshot"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      Account: {
        payload: Prisma.$AccountPayload<ExtArgs>
        fields: Prisma.AccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findFirst: {
            args: Prisma.AccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findMany: {
            args: Prisma.AccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          create: {
            args: Prisma.AccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          createMany: {
            args: Prisma.AccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AccountCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          delete: {
            args: Prisma.AccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          update: {
            args: Prisma.AccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          deleteMany: {
            args: Prisma.AccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          aggregate: {
            args: Prisma.AccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccount>
          }
          groupBy: {
            args: Prisma.AccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccountCountArgs<ExtArgs>
            result: $Utils.Optional<AccountCountAggregateOutputType> | number
          }
        }
      }
      Session: {
        payload: Prisma.$SessionPayload<ExtArgs>
        fields: Prisma.SessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findFirst: {
            args: Prisma.SessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findMany: {
            args: Prisma.SessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          create: {
            args: Prisma.SessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          createMany: {
            args: Prisma.SessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          delete: {
            args: Prisma.SessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          update: {
            args: Prisma.SessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          deleteMany: {
            args: Prisma.SessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          aggregate: {
            args: Prisma.SessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSession>
          }
          groupBy: {
            args: Prisma.SessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionCountArgs<ExtArgs>
            result: $Utils.Optional<SessionCountAggregateOutputType> | number
          }
        }
      }
      FamilyGroup: {
        payload: Prisma.$FamilyGroupPayload<ExtArgs>
        fields: Prisma.FamilyGroupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FamilyGroupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FamilyGroupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          findFirst: {
            args: Prisma.FamilyGroupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FamilyGroupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          findMany: {
            args: Prisma.FamilyGroupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>[]
          }
          create: {
            args: Prisma.FamilyGroupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          createMany: {
            args: Prisma.FamilyGroupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.FamilyGroupCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>[]
          }
          delete: {
            args: Prisma.FamilyGroupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          update: {
            args: Prisma.FamilyGroupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          deleteMany: {
            args: Prisma.FamilyGroupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FamilyGroupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FamilyGroupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupPayload>
          }
          aggregate: {
            args: Prisma.FamilyGroupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFamilyGroup>
          }
          groupBy: {
            args: Prisma.FamilyGroupGroupByArgs<ExtArgs>
            result: $Utils.Optional<FamilyGroupGroupByOutputType>[]
          }
          count: {
            args: Prisma.FamilyGroupCountArgs<ExtArgs>
            result: $Utils.Optional<FamilyGroupCountAggregateOutputType> | number
          }
        }
      }
      FamilyGroupMember: {
        payload: Prisma.$FamilyGroupMemberPayload<ExtArgs>
        fields: Prisma.FamilyGroupMemberFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FamilyGroupMemberFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FamilyGroupMemberFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          findFirst: {
            args: Prisma.FamilyGroupMemberFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FamilyGroupMemberFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          findMany: {
            args: Prisma.FamilyGroupMemberFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>[]
          }
          create: {
            args: Prisma.FamilyGroupMemberCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          createMany: {
            args: Prisma.FamilyGroupMemberCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.FamilyGroupMemberCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>[]
          }
          delete: {
            args: Prisma.FamilyGroupMemberDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          update: {
            args: Prisma.FamilyGroupMemberUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          deleteMany: {
            args: Prisma.FamilyGroupMemberDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FamilyGroupMemberUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FamilyGroupMemberUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FamilyGroupMemberPayload>
          }
          aggregate: {
            args: Prisma.FamilyGroupMemberAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFamilyGroupMember>
          }
          groupBy: {
            args: Prisma.FamilyGroupMemberGroupByArgs<ExtArgs>
            result: $Utils.Optional<FamilyGroupMemberGroupByOutputType>[]
          }
          count: {
            args: Prisma.FamilyGroupMemberCountArgs<ExtArgs>
            result: $Utils.Optional<FamilyGroupMemberCountAggregateOutputType> | number
          }
        }
      }
      Subscription: {
        payload: Prisma.$SubscriptionPayload<ExtArgs>
        fields: Prisma.SubscriptionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SubscriptionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SubscriptionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          findFirst: {
            args: Prisma.SubscriptionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SubscriptionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          findMany: {
            args: Prisma.SubscriptionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>[]
          }
          create: {
            args: Prisma.SubscriptionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          createMany: {
            args: Prisma.SubscriptionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SubscriptionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>[]
          }
          delete: {
            args: Prisma.SubscriptionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          update: {
            args: Prisma.SubscriptionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          deleteMany: {
            args: Prisma.SubscriptionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SubscriptionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SubscriptionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          aggregate: {
            args: Prisma.SubscriptionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSubscription>
          }
          groupBy: {
            args: Prisma.SubscriptionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SubscriptionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SubscriptionCountArgs<ExtArgs>
            result: $Utils.Optional<SubscriptionCountAggregateOutputType> | number
          }
        }
      }
      WatchlistItem: {
        payload: Prisma.$WatchlistItemPayload<ExtArgs>
        fields: Prisma.WatchlistItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WatchlistItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WatchlistItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          findFirst: {
            args: Prisma.WatchlistItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WatchlistItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          findMany: {
            args: Prisma.WatchlistItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>[]
          }
          create: {
            args: Prisma.WatchlistItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          createMany: {
            args: Prisma.WatchlistItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WatchlistItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>[]
          }
          delete: {
            args: Prisma.WatchlistItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          update: {
            args: Prisma.WatchlistItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          deleteMany: {
            args: Prisma.WatchlistItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WatchlistItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WatchlistItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WatchlistItemPayload>
          }
          aggregate: {
            args: Prisma.WatchlistItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWatchlistItem>
          }
          groupBy: {
            args: Prisma.WatchlistItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<WatchlistItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.WatchlistItemCountArgs<ExtArgs>
            result: $Utils.Optional<WatchlistItemCountAggregateOutputType> | number
          }
        }
      }
      Exposure: {
        payload: Prisma.$ExposurePayload<ExtArgs>
        fields: Prisma.ExposureFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExposureFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExposureFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          findFirst: {
            args: Prisma.ExposureFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExposureFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          findMany: {
            args: Prisma.ExposureFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>[]
          }
          create: {
            args: Prisma.ExposureCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          createMany: {
            args: Prisma.ExposureCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExposureCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>[]
          }
          delete: {
            args: Prisma.ExposureDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          update: {
            args: Prisma.ExposureUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          deleteMany: {
            args: Prisma.ExposureDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExposureUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExposureUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExposurePayload>
          }
          aggregate: {
            args: Prisma.ExposureAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExposure>
          }
          groupBy: {
            args: Prisma.ExposureGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExposureGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExposureCountArgs<ExtArgs>
            result: $Utils.Optional<ExposureCountAggregateOutputType> | number
          }
        }
      }
      Alert: {
        payload: Prisma.$AlertPayload<ExtArgs>
        fields: Prisma.AlertFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AlertFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AlertFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          findFirst: {
            args: Prisma.AlertFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AlertFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          findMany: {
            args: Prisma.AlertFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>[]
          }
          create: {
            args: Prisma.AlertCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          createMany: {
            args: Prisma.AlertCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AlertCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>[]
          }
          delete: {
            args: Prisma.AlertDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          update: {
            args: Prisma.AlertUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          deleteMany: {
            args: Prisma.AlertDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AlertUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AlertUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AlertPayload>
          }
          aggregate: {
            args: Prisma.AlertAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAlert>
          }
          groupBy: {
            args: Prisma.AlertGroupByArgs<ExtArgs>
            result: $Utils.Optional<AlertGroupByOutputType>[]
          }
          count: {
            args: Prisma.AlertCountArgs<ExtArgs>
            result: $Utils.Optional<AlertCountAggregateOutputType> | number
          }
        }
      }
      VoiceEnrollment: {
        payload: Prisma.$VoiceEnrollmentPayload<ExtArgs>
        fields: Prisma.VoiceEnrollmentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VoiceEnrollmentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VoiceEnrollmentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          findFirst: {
            args: Prisma.VoiceEnrollmentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VoiceEnrollmentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          findMany: {
            args: Prisma.VoiceEnrollmentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>[]
          }
          create: {
            args: Prisma.VoiceEnrollmentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          createMany: {
            args: Prisma.VoiceEnrollmentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.VoiceEnrollmentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>[]
          }
          delete: {
            args: Prisma.VoiceEnrollmentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          update: {
            args: Prisma.VoiceEnrollmentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          deleteMany: {
            args: Prisma.VoiceEnrollmentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VoiceEnrollmentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VoiceEnrollmentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceEnrollmentPayload>
          }
          aggregate: {
            args: Prisma.VoiceEnrollmentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVoiceEnrollment>
          }
          groupBy: {
            args: Prisma.VoiceEnrollmentGroupByArgs<ExtArgs>
            result: $Utils.Optional<VoiceEnrollmentGroupByOutputType>[]
          }
          count: {
            args: Prisma.VoiceEnrollmentCountArgs<ExtArgs>
            result: $Utils.Optional<VoiceEnrollmentCountAggregateOutputType> | number
          }
        }
      }
      VoiceAnalysis: {
        payload: Prisma.$VoiceAnalysisPayload<ExtArgs>
        fields: Prisma.VoiceAnalysisFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VoiceAnalysisFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VoiceAnalysisFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          findFirst: {
            args: Prisma.VoiceAnalysisFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VoiceAnalysisFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          findMany: {
            args: Prisma.VoiceAnalysisFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>[]
          }
          create: {
            args: Prisma.VoiceAnalysisCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          createMany: {
            args: Prisma.VoiceAnalysisCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.VoiceAnalysisCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>[]
          }
          delete: {
            args: Prisma.VoiceAnalysisDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          update: {
            args: Prisma.VoiceAnalysisUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          deleteMany: {
            args: Prisma.VoiceAnalysisDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VoiceAnalysisUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VoiceAnalysisUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VoiceAnalysisPayload>
          }
          aggregate: {
            args: Prisma.VoiceAnalysisAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVoiceAnalysis>
          }
          groupBy: {
            args: Prisma.VoiceAnalysisGroupByArgs<ExtArgs>
            result: $Utils.Optional<VoiceAnalysisGroupByOutputType>[]
          }
          count: {
            args: Prisma.VoiceAnalysisCountArgs<ExtArgs>
            result: $Utils.Optional<VoiceAnalysisCountAggregateOutputType> | number
          }
        }
      }
      SpamFeedback: {
        payload: Prisma.$SpamFeedbackPayload<ExtArgs>
        fields: Prisma.SpamFeedbackFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SpamFeedbackFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SpamFeedbackFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          findFirst: {
            args: Prisma.SpamFeedbackFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SpamFeedbackFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          findMany: {
            args: Prisma.SpamFeedbackFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>[]
          }
          create: {
            args: Prisma.SpamFeedbackCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          createMany: {
            args: Prisma.SpamFeedbackCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SpamFeedbackCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>[]
          }
          delete: {
            args: Prisma.SpamFeedbackDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          update: {
            args: Prisma.SpamFeedbackUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          deleteMany: {
            args: Prisma.SpamFeedbackDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SpamFeedbackUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SpamFeedbackUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamFeedbackPayload>
          }
          aggregate: {
            args: Prisma.SpamFeedbackAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSpamFeedback>
          }
          groupBy: {
            args: Prisma.SpamFeedbackGroupByArgs<ExtArgs>
            result: $Utils.Optional<SpamFeedbackGroupByOutputType>[]
          }
          count: {
            args: Prisma.SpamFeedbackCountArgs<ExtArgs>
            result: $Utils.Optional<SpamFeedbackCountAggregateOutputType> | number
          }
        }
      }
      SpamRule: {
        payload: Prisma.$SpamRulePayload<ExtArgs>
        fields: Prisma.SpamRuleFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SpamRuleFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SpamRuleFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          findFirst: {
            args: Prisma.SpamRuleFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SpamRuleFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          findMany: {
            args: Prisma.SpamRuleFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>[]
          }
          create: {
            args: Prisma.SpamRuleCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          createMany: {
            args: Prisma.SpamRuleCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SpamRuleCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>[]
          }
          delete: {
            args: Prisma.SpamRuleDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          update: {
            args: Prisma.SpamRuleUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          deleteMany: {
            args: Prisma.SpamRuleDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SpamRuleUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SpamRuleUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SpamRulePayload>
          }
          aggregate: {
            args: Prisma.SpamRuleAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSpamRule>
          }
          groupBy: {
            args: Prisma.SpamRuleGroupByArgs<ExtArgs>
            result: $Utils.Optional<SpamRuleGroupByOutputType>[]
          }
          count: {
            args: Prisma.SpamRuleCountArgs<ExtArgs>
            result: $Utils.Optional<SpamRuleCountAggregateOutputType> | number
          }
        }
      }
      AuditLog: {
        payload: Prisma.$AuditLogPayload<ExtArgs>
        fields: Prisma.AuditLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AuditLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AuditLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          findFirst: {
            args: Prisma.AuditLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AuditLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          findMany: {
            args: Prisma.AuditLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>[]
          }
          create: {
            args: Prisma.AuditLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          createMany: {
            args: Prisma.AuditLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AuditLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>[]
          }
          delete: {
            args: Prisma.AuditLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          update: {
            args: Prisma.AuditLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          deleteMany: {
            args: Prisma.AuditLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AuditLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AuditLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuditLogPayload>
          }
          aggregate: {
            args: Prisma.AuditLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAuditLog>
          }
          groupBy: {
            args: Prisma.AuditLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<AuditLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.AuditLogCountArgs<ExtArgs>
            result: $Utils.Optional<AuditLogCountAggregateOutputType> | number
          }
        }
      }
      KPISnapshot: {
        payload: Prisma.$KPISnapshotPayload<ExtArgs>
        fields: Prisma.KPISnapshotFieldRefs
        operations: {
          findUnique: {
            args: Prisma.KPISnapshotFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.KPISnapshotFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          findFirst: {
            args: Prisma.KPISnapshotFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.KPISnapshotFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          findMany: {
            args: Prisma.KPISnapshotFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>[]
          }
          create: {
            args: Prisma.KPISnapshotCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          createMany: {
            args: Prisma.KPISnapshotCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.KPISnapshotCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>[]
          }
          delete: {
            args: Prisma.KPISnapshotDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          update: {
            args: Prisma.KPISnapshotUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          deleteMany: {
            args: Prisma.KPISnapshotDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.KPISnapshotUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.KPISnapshotUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KPISnapshotPayload>
          }
          aggregate: {
            args: Prisma.KPISnapshotAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateKPISnapshot>
          }
          groupBy: {
            args: Prisma.KPISnapshotGroupByArgs<ExtArgs>
            result: $Utils.Optional<KPISnapshotGroupByOutputType>[]
          }
          count: {
            args: Prisma.KPISnapshotCountArgs<ExtArgs>
            result: $Utils.Optional<KPISnapshotCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { emit: 'stdout', level: 'query' },
     *   { emit: 'stdout', level: 'info' },
     *   { emit: 'stdout', level: 'warn' }
     *   { emit: 'stdout', level: 'error' }
     * ]
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
  }


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

  export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
  export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
    GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
    : never

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

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


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

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

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

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

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

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    accounts: number
    sessions: number
    familyGroups: number
    familyGroupOwned: number
    subscriptions: number
    alerts: number
    voiceEnrollments: number
    voiceAnalyses: number
    spamFeedback: number
    spamRules: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | UserCountOutputTypeCountAccountsArgs
    sessions?: boolean | UserCountOutputTypeCountSessionsArgs
    familyGroups?: boolean | UserCountOutputTypeCountFamilyGroupsArgs
    familyGroupOwned?: boolean | UserCountOutputTypeCountFamilyGroupOwnedArgs
    subscriptions?: boolean | UserCountOutputTypeCountSubscriptionsArgs
    alerts?: boolean | UserCountOutputTypeCountAlertsArgs
    voiceEnrollments?: boolean | UserCountOutputTypeCountVoiceEnrollmentsArgs
    voiceAnalyses?: boolean | UserCountOutputTypeCountVoiceAnalysesArgs
    spamFeedback?: boolean | UserCountOutputTypeCountSpamFeedbackArgs
    spamRules?: boolean | UserCountOutputTypeCountSpamRulesArgs
  }

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

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

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

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

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

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

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

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

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

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


  /**
   * Count Type FamilyGroupCountOutputType
   */

  export type FamilyGroupCountOutputType = {
    members: number
    subscriptions: number
  }

  export type FamilyGroupCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    members?: boolean | FamilyGroupCountOutputTypeCountMembersArgs
    subscriptions?: boolean | FamilyGroupCountOutputTypeCountSubscriptionsArgs
  }

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

  /**
   * FamilyGroupCountOutputType without action
   */
  export type FamilyGroupCountOutputTypeCountMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FamilyGroupMemberWhereInput
  }

  /**
   * FamilyGroupCountOutputType without action
   */
  export type FamilyGroupCountOutputTypeCountSubscriptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SubscriptionWhereInput
  }


  /**
   * Count Type SubscriptionCountOutputType
   */

  export type SubscriptionCountOutputType = {
    watchlistItems: number
    exposures: number
    alerts: number
  }

  export type SubscriptionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    watchlistItems?: boolean | SubscriptionCountOutputTypeCountWatchlistItemsArgs
    exposures?: boolean | SubscriptionCountOutputTypeCountExposuresArgs
    alerts?: boolean | SubscriptionCountOutputTypeCountAlertsArgs
  }

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

  /**
   * SubscriptionCountOutputType without action
   */
  export type SubscriptionCountOutputTypeCountWatchlistItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WatchlistItemWhereInput
  }

  /**
   * SubscriptionCountOutputType without action
   */
  export type SubscriptionCountOutputTypeCountExposuresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExposureWhereInput
  }

  /**
   * SubscriptionCountOutputType without action
   */
  export type SubscriptionCountOutputTypeCountAlertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AlertWhereInput
  }


  /**
   * Count Type WatchlistItemCountOutputType
   */

  export type WatchlistItemCountOutputType = {
    exposures: number
  }

  export type WatchlistItemCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    exposures?: boolean | WatchlistItemCountOutputTypeCountExposuresArgs
  }

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

  /**
   * WatchlistItemCountOutputType without action
   */
  export type WatchlistItemCountOutputTypeCountExposuresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExposureWhereInput
  }


  /**
   * Count Type ExposureCountOutputType
   */

  export type ExposureCountOutputType = {
    alerts: number
  }

  export type ExposureCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    alerts?: boolean | ExposureCountOutputTypeCountAlertsArgs
  }

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

  /**
   * ExposureCountOutputType without action
   */
  export type ExposureCountOutputTypeCountAlertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AlertWhereInput
  }


  /**
   * Count Type VoiceEnrollmentCountOutputType
   */

  export type VoiceEnrollmentCountOutputType = {
    analyses: number
  }

  export type VoiceEnrollmentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    analyses?: boolean | VoiceEnrollmentCountOutputTypeCountAnalysesArgs
  }

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

  /**
   * VoiceEnrollmentCountOutputType without action
   */
  export type VoiceEnrollmentCountOutputTypeCountAnalysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VoiceAnalysisWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    email: string | null
    emailVerified: Date | null
    name: string | null
    image: string | null
    role: $Enums.UserRole | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    email: string | null
    emailVerified: Date | null
    name: string | null
    image: string | null
    role: $Enums.UserRole | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    email: number
    emailVerified: number
    name: number
    image: number
    role: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    email?: true
    emailVerified?: true
    name?: true
    image?: true
    role?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    email?: true
    emailVerified?: true
    name?: true
    image?: true
    role?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    email?: true
    emailVerified?: true
    name?: true
    image?: true
    role?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which User to aggregate.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Users
    **/
    _count?: true | UserCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserMaxAggregateInputType
  }

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




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

  export type UserGroupByOutputType = {
    id: string
    email: string
    emailVerified: Date | null
    name: string | null
    image: string | null
    role: $Enums.UserRole
    createdAt: Date
    updatedAt: Date
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    emailVerified?: boolean
    name?: boolean
    image?: boolean
    role?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    accounts?: boolean | User$accountsArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    familyGroups?: boolean | User$familyGroupsArgs<ExtArgs>
    familyGroupOwned?: boolean | User$familyGroupOwnedArgs<ExtArgs>
    subscriptions?: boolean | User$subscriptionsArgs<ExtArgs>
    alerts?: boolean | User$alertsArgs<ExtArgs>
    voiceEnrollments?: boolean | User$voiceEnrollmentsArgs<ExtArgs>
    voiceAnalyses?: boolean | User$voiceAnalysesArgs<ExtArgs>
    spamFeedback?: boolean | User$spamFeedbackArgs<ExtArgs>
    spamRules?: boolean | User$spamRulesArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    emailVerified?: boolean
    name?: boolean
    image?: boolean
    role?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    email?: boolean
    emailVerified?: boolean
    name?: boolean
    image?: boolean
    role?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | User$accountsArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    familyGroups?: boolean | User$familyGroupsArgs<ExtArgs>
    familyGroupOwned?: boolean | User$familyGroupOwnedArgs<ExtArgs>
    subscriptions?: boolean | User$subscriptionsArgs<ExtArgs>
    alerts?: boolean | User$alertsArgs<ExtArgs>
    voiceEnrollments?: boolean | User$voiceEnrollmentsArgs<ExtArgs>
    voiceAnalyses?: boolean | User$voiceAnalysesArgs<ExtArgs>
    spamFeedback?: boolean | User$spamFeedbackArgs<ExtArgs>
    spamRules?: boolean | User$spamRulesArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      accounts: Prisma.$AccountPayload<ExtArgs>[]
      sessions: Prisma.$SessionPayload<ExtArgs>[]
      familyGroups: Prisma.$FamilyGroupMemberPayload<ExtArgs>[]
      familyGroupOwned: Prisma.$FamilyGroupPayload<ExtArgs>[]
      subscriptions: Prisma.$SubscriptionPayload<ExtArgs>[]
      alerts: Prisma.$AlertPayload<ExtArgs>[]
      voiceEnrollments: Prisma.$VoiceEnrollmentPayload<ExtArgs>[]
      voiceAnalyses: Prisma.$VoiceAnalysisPayload<ExtArgs>[]
      spamFeedback: Prisma.$SpamFeedbackPayload<ExtArgs>[]
      spamRules: Prisma.$SpamRulePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string
      emailVerified: Date | null
      name: string | null
      image: string | null
      role: $Enums.UserRole
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    accounts<T extends User$accountsArgs<ExtArgs> = {}>(args?: Subset<T, User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany"> | Null>
    sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany"> | Null>
    familyGroups<T extends User$familyGroupsArgs<ExtArgs> = {}>(args?: Subset<T, User$familyGroupsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FamilyGroupMemberPayload<ExtArgs>, T, "findMany"> | Null>
    familyGroupOwned<T extends User$familyGroupOwnedArgs<ExtArgs> = {}>(args?: Subset<T, User$familyGroupOwnedArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FamilyGroupPayload<ExtArgs>, T, "findMany"> | Null>
    subscriptions<T extends User$subscriptionsArgs<ExtArgs> = {}>(args?: Subset<T, User$subscriptionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findMany"> | Null>
    alerts<T extends User$alertsArgs<ExtArgs> = {}>(args?: Subset<T, User$alertsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AlertPayload<ExtArgs>, T, "findMany"> | Null>
    voiceEnrollments<T extends User$voiceEnrollmentsArgs<ExtArgs> = {}>(args?: Subset<T, User$voiceEnrollmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VoiceEnrollmentPayload<ExtArgs>, T, "findMany"> | Null>
    voiceAnalyses<T extends User$voiceAnalysesArgs<ExtArgs> = {}>(args?: Subset<T, User$voiceAnalysesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VoiceAnalysisPayload<ExtArgs>, T, "findMany"> | Null>
    spamFeedback<T extends User$spamFeedbackArgs<ExtArgs> = {}>(args?: Subset<T, User$spamFeedbackArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpamFeedbackPayload<ExtArgs>, T, "findMany"> | Null>
    spamRules<T extends User$spamRulesArgs<ExtArgs> = {}>(args?: Subset<T, User$spamRulesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpamRulePayload<ExtArgs>, T, "findMany"> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the User model
   */ 
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly emailVerified: FieldRef<"User", 'DateTime'>
    readonly name: FieldRef<"User", 'String'>
    readonly image: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'UserRole'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly updatedAt: FieldRef<"User", 'DateTime'>
  }
    

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

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

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

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

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

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

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

  /**
   * User createManyAndReturn
   */
  export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
    skipDuplicates?: boolean
  }

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

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

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

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

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

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

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

  /**
   * User.familyGroups
   */
  export type User$familyGroupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    where?: FamilyGroupMemberWhereInput
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    cursor?: FamilyGroupMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: FamilyGroupMemberScalarFieldEnum | FamilyGroupMemberScalarFieldEnum[]
  }

  /**
   * User.familyGroupOwned
   */
  export type User$familyGroupOwnedArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    where?: FamilyGroupWhereInput
    orderBy?: FamilyGroupOrderByWithRelationInput | FamilyGroupOrderByWithRelationInput[]
    cursor?: FamilyGroupWhereUniqueInput
    take?: number
    skip?: number
    distinct?: FamilyGroupScalarFieldEnum | FamilyGroupScalarFieldEnum[]
  }

  /**
   * User.subscriptions
   */
  export type User$subscriptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    where?: SubscriptionWhereInput
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    cursor?: SubscriptionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * User.alerts
   */
  export type User$alertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    where?: AlertWhereInput
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    cursor?: AlertWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

  /**
   * User.voiceEnrollments
   */
  export type User$voiceEnrollmentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    where?: VoiceEnrollmentWhereInput
    orderBy?: VoiceEnrollmentOrderByWithRelationInput | VoiceEnrollmentOrderByWithRelationInput[]
    cursor?: VoiceEnrollmentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VoiceEnrollmentScalarFieldEnum | VoiceEnrollmentScalarFieldEnum[]
  }

  /**
   * User.voiceAnalyses
   */
  export type User$voiceAnalysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    where?: VoiceAnalysisWhereInput
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    cursor?: VoiceAnalysisWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VoiceAnalysisScalarFieldEnum | VoiceAnalysisScalarFieldEnum[]
  }

  /**
   * User.spamFeedback
   */
  export type User$spamFeedbackArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    where?: SpamFeedbackWhereInput
    orderBy?: SpamFeedbackOrderByWithRelationInput | SpamFeedbackOrderByWithRelationInput[]
    cursor?: SpamFeedbackWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SpamFeedbackScalarFieldEnum | SpamFeedbackScalarFieldEnum[]
  }

  /**
   * User.spamRules
   */
  export type User$spamRulesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    where?: SpamRuleWhereInput
    orderBy?: SpamRuleOrderByWithRelationInput | SpamRuleOrderByWithRelationInput[]
    cursor?: SpamRuleWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SpamRuleScalarFieldEnum | SpamRuleScalarFieldEnum[]
  }

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


  /**
   * Model Account
   */

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

  export type AccountAvgAggregateOutputType = {
    expires_at: number | null
  }

  export type AccountSumAggregateOutputType = {
    expires_at: number | null
  }

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

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

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


  export type AccountAvgAggregateInputType = {
    expires_at?: true
  }

  export type AccountSumAggregateInputType = {
    expires_at?: true
  }

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

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

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

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

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




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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  /**
   * Model Session
   */

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

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

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

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


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

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

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

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

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




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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  /**
   * Model FamilyGroup
   */

  export type AggregateFamilyGroup = {
    _count: FamilyGroupCountAggregateOutputType | null
    _min: FamilyGroupMinAggregateOutputType | null
    _max: FamilyGroupMaxAggregateOutputType | null
  }

  export type FamilyGroupMinAggregateOutputType = {
    id: string | null
    name: string | null
    ownerId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FamilyGroupMaxAggregateOutputType = {
    id: string | null
    name: string | null
    ownerId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FamilyGroupCountAggregateOutputType = {
    id: number
    name: number
    ownerId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type FamilyGroupMinAggregateInputType = {
    id?: true
    name?: true
    ownerId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FamilyGroupMaxAggregateInputType = {
    id?: true
    name?: true
    ownerId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FamilyGroupCountAggregateInputType = {
    id?: true
    name?: true
    ownerId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type FamilyGroupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FamilyGroup to aggregate.
     */
    where?: FamilyGroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroups to fetch.
     */
    orderBy?: FamilyGroupOrderByWithRelationInput | FamilyGroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FamilyGroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned FamilyGroups
    **/
    _count?: true | FamilyGroupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FamilyGroupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FamilyGroupMaxAggregateInputType
  }

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




  export type FamilyGroupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FamilyGroupWhereInput
    orderBy?: FamilyGroupOrderByWithAggregationInput | FamilyGroupOrderByWithAggregationInput[]
    by: FamilyGroupScalarFieldEnum[] | FamilyGroupScalarFieldEnum
    having?: FamilyGroupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FamilyGroupCountAggregateInputType | true
    _min?: FamilyGroupMinAggregateInputType
    _max?: FamilyGroupMaxAggregateInputType
  }

  export type FamilyGroupGroupByOutputType = {
    id: string
    name: string
    ownerId: string
    createdAt: Date
    updatedAt: Date
    _count: FamilyGroupCountAggregateOutputType | null
    _min: FamilyGroupMinAggregateOutputType | null
    _max: FamilyGroupMaxAggregateOutputType | null
  }

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


  export type FamilyGroupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    ownerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    owner?: boolean | UserDefaultArgs<ExtArgs>
    members?: boolean | FamilyGroup$membersArgs<ExtArgs>
    subscriptions?: boolean | FamilyGroup$subscriptionsArgs<ExtArgs>
    _count?: boolean | FamilyGroupCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["familyGroup"]>

  export type FamilyGroupSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    ownerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    owner?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["familyGroup"]>

  export type FamilyGroupSelectScalar = {
    id?: boolean
    name?: boolean
    ownerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type FamilyGroupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    owner?: boolean | UserDefaultArgs<ExtArgs>
    members?: boolean | FamilyGroup$membersArgs<ExtArgs>
    subscriptions?: boolean | FamilyGroup$subscriptionsArgs<ExtArgs>
    _count?: boolean | FamilyGroupCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type FamilyGroupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    owner?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $FamilyGroupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "FamilyGroup"
    objects: {
      owner: Prisma.$UserPayload<ExtArgs>
      members: Prisma.$FamilyGroupMemberPayload<ExtArgs>[]
      subscriptions: Prisma.$SubscriptionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      ownerId: string
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["familyGroup"]>
    composites: {}
  }

  type FamilyGroupGetPayload<S extends boolean | null | undefined | FamilyGroupDefaultArgs> = $Result.GetResult<Prisma.$FamilyGroupPayload, S>

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

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

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

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

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

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

    /**
     * Create a FamilyGroup.
     * @param {FamilyGroupCreateArgs} args - Arguments to create a FamilyGroup.
     * @example
     * // Create one FamilyGroup
     * const FamilyGroup = await prisma.familyGroup.create({
     *   data: {
     *     // ... data to create a FamilyGroup
     *   }
     * })
     * 
     */
    create<T extends FamilyGroupCreateArgs>(args: SelectSubset<T, FamilyGroupCreateArgs<ExtArgs>>): Prisma__FamilyGroupClient<$Result.GetResult<Prisma.$FamilyGroupPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a FamilyGroup.
     * @param {FamilyGroupDeleteArgs} args - Arguments to delete one FamilyGroup.
     * @example
     * // Delete one FamilyGroup
     * const FamilyGroup = await prisma.familyGroup.delete({
     *   where: {
     *     // ... filter to delete one FamilyGroup
     *   }
     * })
     * 
     */
    delete<T extends FamilyGroupDeleteArgs>(args: SelectSubset<T, FamilyGroupDeleteArgs<ExtArgs>>): Prisma__FamilyGroupClient<$Result.GetResult<Prisma.$FamilyGroupPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the FamilyGroup model
   */ 
  interface FamilyGroupFieldRefs {
    readonly id: FieldRef<"FamilyGroup", 'String'>
    readonly name: FieldRef<"FamilyGroup", 'String'>
    readonly ownerId: FieldRef<"FamilyGroup", 'String'>
    readonly createdAt: FieldRef<"FamilyGroup", 'DateTime'>
    readonly updatedAt: FieldRef<"FamilyGroup", 'DateTime'>
  }
    

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

  /**
   * FamilyGroup findUniqueOrThrow
   */
  export type FamilyGroupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroup to fetch.
     */
    where: FamilyGroupWhereUniqueInput
  }

  /**
   * FamilyGroup findFirst
   */
  export type FamilyGroupFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroup to fetch.
     */
    where?: FamilyGroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroups to fetch.
     */
    orderBy?: FamilyGroupOrderByWithRelationInput | FamilyGroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FamilyGroups.
     */
    cursor?: FamilyGroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FamilyGroups.
     */
    distinct?: FamilyGroupScalarFieldEnum | FamilyGroupScalarFieldEnum[]
  }

  /**
   * FamilyGroup findFirstOrThrow
   */
  export type FamilyGroupFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroup to fetch.
     */
    where?: FamilyGroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroups to fetch.
     */
    orderBy?: FamilyGroupOrderByWithRelationInput | FamilyGroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FamilyGroups.
     */
    cursor?: FamilyGroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FamilyGroups.
     */
    distinct?: FamilyGroupScalarFieldEnum | FamilyGroupScalarFieldEnum[]
  }

  /**
   * FamilyGroup findMany
   */
  export type FamilyGroupFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroups to fetch.
     */
    where?: FamilyGroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroups to fetch.
     */
    orderBy?: FamilyGroupOrderByWithRelationInput | FamilyGroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing FamilyGroups.
     */
    cursor?: FamilyGroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroups.
     */
    skip?: number
    distinct?: FamilyGroupScalarFieldEnum | FamilyGroupScalarFieldEnum[]
  }

  /**
   * FamilyGroup create
   */
  export type FamilyGroupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * The data needed to create a FamilyGroup.
     */
    data: XOR<FamilyGroupCreateInput, FamilyGroupUncheckedCreateInput>
  }

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

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

  /**
   * FamilyGroup update
   */
  export type FamilyGroupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * The data needed to update a FamilyGroup.
     */
    data: XOR<FamilyGroupUpdateInput, FamilyGroupUncheckedUpdateInput>
    /**
     * Choose, which FamilyGroup to update.
     */
    where: FamilyGroupWhereUniqueInput
  }

  /**
   * FamilyGroup updateMany
   */
  export type FamilyGroupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update FamilyGroups.
     */
    data: XOR<FamilyGroupUpdateManyMutationInput, FamilyGroupUncheckedUpdateManyInput>
    /**
     * Filter which FamilyGroups to update
     */
    where?: FamilyGroupWhereInput
  }

  /**
   * FamilyGroup upsert
   */
  export type FamilyGroupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * The filter to search for the FamilyGroup to update in case it exists.
     */
    where: FamilyGroupWhereUniqueInput
    /**
     * In case the FamilyGroup found by the `where` argument doesn't exist, create a new FamilyGroup with this data.
     */
    create: XOR<FamilyGroupCreateInput, FamilyGroupUncheckedCreateInput>
    /**
     * In case the FamilyGroup was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FamilyGroupUpdateInput, FamilyGroupUncheckedUpdateInput>
  }

  /**
   * FamilyGroup delete
   */
  export type FamilyGroupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    /**
     * Filter which FamilyGroup to delete.
     */
    where: FamilyGroupWhereUniqueInput
  }

  /**
   * FamilyGroup deleteMany
   */
  export type FamilyGroupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FamilyGroups to delete
     */
    where?: FamilyGroupWhereInput
  }

  /**
   * FamilyGroup.members
   */
  export type FamilyGroup$membersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    where?: FamilyGroupMemberWhereInput
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    cursor?: FamilyGroupMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: FamilyGroupMemberScalarFieldEnum | FamilyGroupMemberScalarFieldEnum[]
  }

  /**
   * FamilyGroup.subscriptions
   */
  export type FamilyGroup$subscriptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    where?: SubscriptionWhereInput
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    cursor?: SubscriptionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

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


  /**
   * Model FamilyGroupMember
   */

  export type AggregateFamilyGroupMember = {
    _count: FamilyGroupMemberCountAggregateOutputType | null
    _min: FamilyGroupMemberMinAggregateOutputType | null
    _max: FamilyGroupMemberMaxAggregateOutputType | null
  }

  export type FamilyGroupMemberMinAggregateOutputType = {
    id: string | null
    groupId: string | null
    userId: string | null
    role: $Enums.FamilyMemberRole | null
    joinedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FamilyGroupMemberMaxAggregateOutputType = {
    id: string | null
    groupId: string | null
    userId: string | null
    role: $Enums.FamilyMemberRole | null
    joinedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FamilyGroupMemberCountAggregateOutputType = {
    id: number
    groupId: number
    userId: number
    role: number
    joinedAt: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type FamilyGroupMemberMinAggregateInputType = {
    id?: true
    groupId?: true
    userId?: true
    role?: true
    joinedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FamilyGroupMemberMaxAggregateInputType = {
    id?: true
    groupId?: true
    userId?: true
    role?: true
    joinedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FamilyGroupMemberCountAggregateInputType = {
    id?: true
    groupId?: true
    userId?: true
    role?: true
    joinedAt?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type FamilyGroupMemberAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FamilyGroupMember to aggregate.
     */
    where?: FamilyGroupMemberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroupMembers to fetch.
     */
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FamilyGroupMemberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroupMembers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroupMembers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned FamilyGroupMembers
    **/
    _count?: true | FamilyGroupMemberCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FamilyGroupMemberMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FamilyGroupMemberMaxAggregateInputType
  }

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




  export type FamilyGroupMemberGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FamilyGroupMemberWhereInput
    orderBy?: FamilyGroupMemberOrderByWithAggregationInput | FamilyGroupMemberOrderByWithAggregationInput[]
    by: FamilyGroupMemberScalarFieldEnum[] | FamilyGroupMemberScalarFieldEnum
    having?: FamilyGroupMemberScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FamilyGroupMemberCountAggregateInputType | true
    _min?: FamilyGroupMemberMinAggregateInputType
    _max?: FamilyGroupMemberMaxAggregateInputType
  }

  export type FamilyGroupMemberGroupByOutputType = {
    id: string
    groupId: string
    userId: string
    role: $Enums.FamilyMemberRole
    joinedAt: Date
    createdAt: Date
    updatedAt: Date
    _count: FamilyGroupMemberCountAggregateOutputType | null
    _min: FamilyGroupMemberMinAggregateOutputType | null
    _max: FamilyGroupMemberMaxAggregateOutputType | null
  }

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


  export type FamilyGroupMemberSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    groupId?: boolean
    userId?: boolean
    role?: boolean
    joinedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    group?: boolean | FamilyGroupDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["familyGroupMember"]>

  export type FamilyGroupMemberSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    groupId?: boolean
    userId?: boolean
    role?: boolean
    joinedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    group?: boolean | FamilyGroupDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["familyGroupMember"]>

  export type FamilyGroupMemberSelectScalar = {
    id?: boolean
    groupId?: boolean
    userId?: boolean
    role?: boolean
    joinedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type FamilyGroupMemberInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | FamilyGroupDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type FamilyGroupMemberIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | FamilyGroupDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $FamilyGroupMemberPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "FamilyGroupMember"
    objects: {
      group: Prisma.$FamilyGroupPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      groupId: string
      userId: string
      role: $Enums.FamilyMemberRole
      joinedAt: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["familyGroupMember"]>
    composites: {}
  }

  type FamilyGroupMemberGetPayload<S extends boolean | null | undefined | FamilyGroupMemberDefaultArgs> = $Result.GetResult<Prisma.$FamilyGroupMemberPayload, S>

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

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

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

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

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

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

    /**
     * Create a FamilyGroupMember.
     * @param {FamilyGroupMemberCreateArgs} args - Arguments to create a FamilyGroupMember.
     * @example
     * // Create one FamilyGroupMember
     * const FamilyGroupMember = await prisma.familyGroupMember.create({
     *   data: {
     *     // ... data to create a FamilyGroupMember
     *   }
     * })
     * 
     */
    create<T extends FamilyGroupMemberCreateArgs>(args: SelectSubset<T, FamilyGroupMemberCreateArgs<ExtArgs>>): Prisma__FamilyGroupMemberClient<$Result.GetResult<Prisma.$FamilyGroupMemberPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a FamilyGroupMember.
     * @param {FamilyGroupMemberDeleteArgs} args - Arguments to delete one FamilyGroupMember.
     * @example
     * // Delete one FamilyGroupMember
     * const FamilyGroupMember = await prisma.familyGroupMember.delete({
     *   where: {
     *     // ... filter to delete one FamilyGroupMember
     *   }
     * })
     * 
     */
    delete<T extends FamilyGroupMemberDeleteArgs>(args: SelectSubset<T, FamilyGroupMemberDeleteArgs<ExtArgs>>): Prisma__FamilyGroupMemberClient<$Result.GetResult<Prisma.$FamilyGroupMemberPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the FamilyGroupMember model
   */ 
  interface FamilyGroupMemberFieldRefs {
    readonly id: FieldRef<"FamilyGroupMember", 'String'>
    readonly groupId: FieldRef<"FamilyGroupMember", 'String'>
    readonly userId: FieldRef<"FamilyGroupMember", 'String'>
    readonly role: FieldRef<"FamilyGroupMember", 'FamilyMemberRole'>
    readonly joinedAt: FieldRef<"FamilyGroupMember", 'DateTime'>
    readonly createdAt: FieldRef<"FamilyGroupMember", 'DateTime'>
    readonly updatedAt: FieldRef<"FamilyGroupMember", 'DateTime'>
  }
    

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

  /**
   * FamilyGroupMember findUniqueOrThrow
   */
  export type FamilyGroupMemberFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroupMember to fetch.
     */
    where: FamilyGroupMemberWhereUniqueInput
  }

  /**
   * FamilyGroupMember findFirst
   */
  export type FamilyGroupMemberFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroupMember to fetch.
     */
    where?: FamilyGroupMemberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroupMembers to fetch.
     */
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FamilyGroupMembers.
     */
    cursor?: FamilyGroupMemberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroupMembers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroupMembers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FamilyGroupMembers.
     */
    distinct?: FamilyGroupMemberScalarFieldEnum | FamilyGroupMemberScalarFieldEnum[]
  }

  /**
   * FamilyGroupMember findFirstOrThrow
   */
  export type FamilyGroupMemberFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroupMember to fetch.
     */
    where?: FamilyGroupMemberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroupMembers to fetch.
     */
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FamilyGroupMembers.
     */
    cursor?: FamilyGroupMemberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroupMembers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroupMembers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FamilyGroupMembers.
     */
    distinct?: FamilyGroupMemberScalarFieldEnum | FamilyGroupMemberScalarFieldEnum[]
  }

  /**
   * FamilyGroupMember findMany
   */
  export type FamilyGroupMemberFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * Filter, which FamilyGroupMembers to fetch.
     */
    where?: FamilyGroupMemberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FamilyGroupMembers to fetch.
     */
    orderBy?: FamilyGroupMemberOrderByWithRelationInput | FamilyGroupMemberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing FamilyGroupMembers.
     */
    cursor?: FamilyGroupMemberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FamilyGroupMembers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FamilyGroupMembers.
     */
    skip?: number
    distinct?: FamilyGroupMemberScalarFieldEnum | FamilyGroupMemberScalarFieldEnum[]
  }

  /**
   * FamilyGroupMember create
   */
  export type FamilyGroupMemberCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * The data needed to create a FamilyGroupMember.
     */
    data: XOR<FamilyGroupMemberCreateInput, FamilyGroupMemberUncheckedCreateInput>
  }

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

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

  /**
   * FamilyGroupMember update
   */
  export type FamilyGroupMemberUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * The data needed to update a FamilyGroupMember.
     */
    data: XOR<FamilyGroupMemberUpdateInput, FamilyGroupMemberUncheckedUpdateInput>
    /**
     * Choose, which FamilyGroupMember to update.
     */
    where: FamilyGroupMemberWhereUniqueInput
  }

  /**
   * FamilyGroupMember updateMany
   */
  export type FamilyGroupMemberUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update FamilyGroupMembers.
     */
    data: XOR<FamilyGroupMemberUpdateManyMutationInput, FamilyGroupMemberUncheckedUpdateManyInput>
    /**
     * Filter which FamilyGroupMembers to update
     */
    where?: FamilyGroupMemberWhereInput
  }

  /**
   * FamilyGroupMember upsert
   */
  export type FamilyGroupMemberUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * The filter to search for the FamilyGroupMember to update in case it exists.
     */
    where: FamilyGroupMemberWhereUniqueInput
    /**
     * In case the FamilyGroupMember found by the `where` argument doesn't exist, create a new FamilyGroupMember with this data.
     */
    create: XOR<FamilyGroupMemberCreateInput, FamilyGroupMemberUncheckedCreateInput>
    /**
     * In case the FamilyGroupMember was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FamilyGroupMemberUpdateInput, FamilyGroupMemberUncheckedUpdateInput>
  }

  /**
   * FamilyGroupMember delete
   */
  export type FamilyGroupMemberDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroupMember
     */
    select?: FamilyGroupMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupMemberInclude<ExtArgs> | null
    /**
     * Filter which FamilyGroupMember to delete.
     */
    where: FamilyGroupMemberWhereUniqueInput
  }

  /**
   * FamilyGroupMember deleteMany
   */
  export type FamilyGroupMemberDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FamilyGroupMembers to delete
     */
    where?: FamilyGroupMemberWhereInput
  }

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


  /**
   * Model Subscription
   */

  export type AggregateSubscription = {
    _count: SubscriptionCountAggregateOutputType | null
    _min: SubscriptionMinAggregateOutputType | null
    _max: SubscriptionMaxAggregateOutputType | null
  }

  export type SubscriptionMinAggregateOutputType = {
    id: string | null
    userId: string | null
    familyGroupId: string | null
    stripeId: string | null
    tier: $Enums.SubscriptionTier | null
    status: $Enums.SubscriptionStatus | null
    currentPeriodStart: Date | null
    currentPeriodEnd: Date | null
    cancelAtPeriodEnd: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SubscriptionMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    familyGroupId: string | null
    stripeId: string | null
    tier: $Enums.SubscriptionTier | null
    status: $Enums.SubscriptionStatus | null
    currentPeriodStart: Date | null
    currentPeriodEnd: Date | null
    cancelAtPeriodEnd: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SubscriptionCountAggregateOutputType = {
    id: number
    userId: number
    familyGroupId: number
    stripeId: number
    tier: number
    status: number
    currentPeriodStart: number
    currentPeriodEnd: number
    cancelAtPeriodEnd: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SubscriptionMinAggregateInputType = {
    id?: true
    userId?: true
    familyGroupId?: true
    stripeId?: true
    tier?: true
    status?: true
    currentPeriodStart?: true
    currentPeriodEnd?: true
    cancelAtPeriodEnd?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SubscriptionMaxAggregateInputType = {
    id?: true
    userId?: true
    familyGroupId?: true
    stripeId?: true
    tier?: true
    status?: true
    currentPeriodStart?: true
    currentPeriodEnd?: true
    cancelAtPeriodEnd?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SubscriptionCountAggregateInputType = {
    id?: true
    userId?: true
    familyGroupId?: true
    stripeId?: true
    tier?: true
    status?: true
    currentPeriodStart?: true
    currentPeriodEnd?: true
    cancelAtPeriodEnd?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SubscriptionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscription to aggregate.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Subscriptions
    **/
    _count?: true | SubscriptionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SubscriptionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SubscriptionMaxAggregateInputType
  }

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




  export type SubscriptionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SubscriptionWhereInput
    orderBy?: SubscriptionOrderByWithAggregationInput | SubscriptionOrderByWithAggregationInput[]
    by: SubscriptionScalarFieldEnum[] | SubscriptionScalarFieldEnum
    having?: SubscriptionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SubscriptionCountAggregateInputType | true
    _min?: SubscriptionMinAggregateInputType
    _max?: SubscriptionMaxAggregateInputType
  }

  export type SubscriptionGroupByOutputType = {
    id: string
    userId: string
    familyGroupId: string | null
    stripeId: string | null
    tier: $Enums.SubscriptionTier
    status: $Enums.SubscriptionStatus
    currentPeriodStart: Date
    currentPeriodEnd: Date
    cancelAtPeriodEnd: boolean
    createdAt: Date
    updatedAt: Date
    _count: SubscriptionCountAggregateOutputType | null
    _min: SubscriptionMinAggregateOutputType | null
    _max: SubscriptionMaxAggregateOutputType | null
  }

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


  export type SubscriptionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    familyGroupId?: boolean
    stripeId?: boolean
    tier?: boolean
    status?: boolean
    currentPeriodStart?: boolean
    currentPeriodEnd?: boolean
    cancelAtPeriodEnd?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    familyGroup?: boolean | Subscription$familyGroupArgs<ExtArgs>
    watchlistItems?: boolean | Subscription$watchlistItemsArgs<ExtArgs>
    exposures?: boolean | Subscription$exposuresArgs<ExtArgs>
    alerts?: boolean | Subscription$alertsArgs<ExtArgs>
    _count?: boolean | SubscriptionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["subscription"]>

  export type SubscriptionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    familyGroupId?: boolean
    stripeId?: boolean
    tier?: boolean
    status?: boolean
    currentPeriodStart?: boolean
    currentPeriodEnd?: boolean
    cancelAtPeriodEnd?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    familyGroup?: boolean | Subscription$familyGroupArgs<ExtArgs>
  }, ExtArgs["result"]["subscription"]>

  export type SubscriptionSelectScalar = {
    id?: boolean
    userId?: boolean
    familyGroupId?: boolean
    stripeId?: boolean
    tier?: boolean
    status?: boolean
    currentPeriodStart?: boolean
    currentPeriodEnd?: boolean
    cancelAtPeriodEnd?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type SubscriptionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    familyGroup?: boolean | Subscription$familyGroupArgs<ExtArgs>
    watchlistItems?: boolean | Subscription$watchlistItemsArgs<ExtArgs>
    exposures?: boolean | Subscription$exposuresArgs<ExtArgs>
    alerts?: boolean | Subscription$alertsArgs<ExtArgs>
    _count?: boolean | SubscriptionCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type SubscriptionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    familyGroup?: boolean | Subscription$familyGroupArgs<ExtArgs>
  }

  export type $SubscriptionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Subscription"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      familyGroup: Prisma.$FamilyGroupPayload<ExtArgs> | null
      watchlistItems: Prisma.$WatchlistItemPayload<ExtArgs>[]
      exposures: Prisma.$ExposurePayload<ExtArgs>[]
      alerts: Prisma.$AlertPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      familyGroupId: string | null
      stripeId: string | null
      tier: $Enums.SubscriptionTier
      status: $Enums.SubscriptionStatus
      currentPeriodStart: Date
      currentPeriodEnd: Date
      cancelAtPeriodEnd: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["subscription"]>
    composites: {}
  }

  type SubscriptionGetPayload<S extends boolean | null | undefined | SubscriptionDefaultArgs> = $Result.GetResult<Prisma.$SubscriptionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Subscription.
     * @param {SubscriptionCreateArgs} args - Arguments to create a Subscription.
     * @example
     * // Create one Subscription
     * const Subscription = await prisma.subscription.create({
     *   data: {
     *     // ... data to create a Subscription
     *   }
     * })
     * 
     */
    create<T extends SubscriptionCreateArgs>(args: SelectSubset<T, SubscriptionCreateArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Subscription.
     * @param {SubscriptionDeleteArgs} args - Arguments to delete one Subscription.
     * @example
     * // Delete one Subscription
     * const Subscription = await prisma.subscription.delete({
     *   where: {
     *     // ... filter to delete one Subscription
     *   }
     * })
     * 
     */
    delete<T extends SubscriptionDeleteArgs>(args: SelectSubset<T, SubscriptionDeleteArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the Subscription model
   */ 
  interface SubscriptionFieldRefs {
    readonly id: FieldRef<"Subscription", 'String'>
    readonly userId: FieldRef<"Subscription", 'String'>
    readonly familyGroupId: FieldRef<"Subscription", 'String'>
    readonly stripeId: FieldRef<"Subscription", 'String'>
    readonly tier: FieldRef<"Subscription", 'SubscriptionTier'>
    readonly status: FieldRef<"Subscription", 'SubscriptionStatus'>
    readonly currentPeriodStart: FieldRef<"Subscription", 'DateTime'>
    readonly currentPeriodEnd: FieldRef<"Subscription", 'DateTime'>
    readonly cancelAtPeriodEnd: FieldRef<"Subscription", 'Boolean'>
    readonly createdAt: FieldRef<"Subscription", 'DateTime'>
    readonly updatedAt: FieldRef<"Subscription", 'DateTime'>
  }
    

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

  /**
   * Subscription findUniqueOrThrow
   */
  export type SubscriptionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription findFirst
   */
  export type SubscriptionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscriptions.
     */
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription findFirstOrThrow
   */
  export type SubscriptionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscriptions.
     */
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription findMany
   */
  export type SubscriptionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscriptions to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscriptions.
     */
    skip?: number
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription create
   */
  export type SubscriptionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The data needed to create a Subscription.
     */
    data: XOR<SubscriptionCreateInput, SubscriptionUncheckedCreateInput>
  }

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

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

  /**
   * Subscription update
   */
  export type SubscriptionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The data needed to update a Subscription.
     */
    data: XOR<SubscriptionUpdateInput, SubscriptionUncheckedUpdateInput>
    /**
     * Choose, which Subscription to update.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription updateMany
   */
  export type SubscriptionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Subscriptions.
     */
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyInput>
    /**
     * Filter which Subscriptions to update
     */
    where?: SubscriptionWhereInput
  }

  /**
   * Subscription upsert
   */
  export type SubscriptionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The filter to search for the Subscription to update in case it exists.
     */
    where: SubscriptionWhereUniqueInput
    /**
     * In case the Subscription found by the `where` argument doesn't exist, create a new Subscription with this data.
     */
    create: XOR<SubscriptionCreateInput, SubscriptionUncheckedCreateInput>
    /**
     * In case the Subscription was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SubscriptionUpdateInput, SubscriptionUncheckedUpdateInput>
  }

  /**
   * Subscription delete
   */
  export type SubscriptionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter which Subscription to delete.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription deleteMany
   */
  export type SubscriptionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscriptions to delete
     */
    where?: SubscriptionWhereInput
  }

  /**
   * Subscription.familyGroup
   */
  export type Subscription$familyGroupArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FamilyGroup
     */
    select?: FamilyGroupSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FamilyGroupInclude<ExtArgs> | null
    where?: FamilyGroupWhereInput
  }

  /**
   * Subscription.watchlistItems
   */
  export type Subscription$watchlistItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    where?: WatchlistItemWhereInput
    orderBy?: WatchlistItemOrderByWithRelationInput | WatchlistItemOrderByWithRelationInput[]
    cursor?: WatchlistItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WatchlistItemScalarFieldEnum | WatchlistItemScalarFieldEnum[]
  }

  /**
   * Subscription.exposures
   */
  export type Subscription$exposuresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    where?: ExposureWhereInput
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    cursor?: ExposureWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExposureScalarFieldEnum | ExposureScalarFieldEnum[]
  }

  /**
   * Subscription.alerts
   */
  export type Subscription$alertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    where?: AlertWhereInput
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    cursor?: AlertWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

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


  /**
   * Model WatchlistItem
   */

  export type AggregateWatchlistItem = {
    _count: WatchlistItemCountAggregateOutputType | null
    _min: WatchlistItemMinAggregateOutputType | null
    _max: WatchlistItemMaxAggregateOutputType | null
  }

  export type WatchlistItemMinAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    type: $Enums.WatchlistType | null
    value: string | null
    hash: string | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type WatchlistItemMaxAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    type: $Enums.WatchlistType | null
    value: string | null
    hash: string | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type WatchlistItemCountAggregateOutputType = {
    id: number
    subscriptionId: number
    type: number
    value: number
    hash: number
    isActive: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type WatchlistItemMinAggregateInputType = {
    id?: true
    subscriptionId?: true
    type?: true
    value?: true
    hash?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type WatchlistItemMaxAggregateInputType = {
    id?: true
    subscriptionId?: true
    type?: true
    value?: true
    hash?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type WatchlistItemCountAggregateInputType = {
    id?: true
    subscriptionId?: true
    type?: true
    value?: true
    hash?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type WatchlistItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WatchlistItem to aggregate.
     */
    where?: WatchlistItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WatchlistItems to fetch.
     */
    orderBy?: WatchlistItemOrderByWithRelationInput | WatchlistItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: WatchlistItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WatchlistItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WatchlistItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned WatchlistItems
    **/
    _count?: true | WatchlistItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: WatchlistItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: WatchlistItemMaxAggregateInputType
  }

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




  export type WatchlistItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WatchlistItemWhereInput
    orderBy?: WatchlistItemOrderByWithAggregationInput | WatchlistItemOrderByWithAggregationInput[]
    by: WatchlistItemScalarFieldEnum[] | WatchlistItemScalarFieldEnum
    having?: WatchlistItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WatchlistItemCountAggregateInputType | true
    _min?: WatchlistItemMinAggregateInputType
    _max?: WatchlistItemMaxAggregateInputType
  }

  export type WatchlistItemGroupByOutputType = {
    id: string
    subscriptionId: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive: boolean
    createdAt: Date
    updatedAt: Date
    _count: WatchlistItemCountAggregateOutputType | null
    _min: WatchlistItemMinAggregateOutputType | null
    _max: WatchlistItemMaxAggregateOutputType | null
  }

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


  export type WatchlistItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    type?: boolean
    value?: boolean
    hash?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    exposures?: boolean | WatchlistItem$exposuresArgs<ExtArgs>
    _count?: boolean | WatchlistItemCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["watchlistItem"]>

  export type WatchlistItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    type?: boolean
    value?: boolean
    hash?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["watchlistItem"]>

  export type WatchlistItemSelectScalar = {
    id?: boolean
    subscriptionId?: boolean
    type?: boolean
    value?: boolean
    hash?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type WatchlistItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    exposures?: boolean | WatchlistItem$exposuresArgs<ExtArgs>
    _count?: boolean | WatchlistItemCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type WatchlistItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
  }

  export type $WatchlistItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WatchlistItem"
    objects: {
      subscription: Prisma.$SubscriptionPayload<ExtArgs>
      exposures: Prisma.$ExposurePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      subscriptionId: string
      type: $Enums.WatchlistType
      value: string
      hash: string
      isActive: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["watchlistItem"]>
    composites: {}
  }

  type WatchlistItemGetPayload<S extends boolean | null | undefined | WatchlistItemDefaultArgs> = $Result.GetResult<Prisma.$WatchlistItemPayload, S>

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

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

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

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

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

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

    /**
     * Create a WatchlistItem.
     * @param {WatchlistItemCreateArgs} args - Arguments to create a WatchlistItem.
     * @example
     * // Create one WatchlistItem
     * const WatchlistItem = await prisma.watchlistItem.create({
     *   data: {
     *     // ... data to create a WatchlistItem
     *   }
     * })
     * 
     */
    create<T extends WatchlistItemCreateArgs>(args: SelectSubset<T, WatchlistItemCreateArgs<ExtArgs>>): Prisma__WatchlistItemClient<$Result.GetResult<Prisma.$WatchlistItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a WatchlistItem.
     * @param {WatchlistItemDeleteArgs} args - Arguments to delete one WatchlistItem.
     * @example
     * // Delete one WatchlistItem
     * const WatchlistItem = await prisma.watchlistItem.delete({
     *   where: {
     *     // ... filter to delete one WatchlistItem
     *   }
     * })
     * 
     */
    delete<T extends WatchlistItemDeleteArgs>(args: SelectSubset<T, WatchlistItemDeleteArgs<ExtArgs>>): Prisma__WatchlistItemClient<$Result.GetResult<Prisma.$WatchlistItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the WatchlistItem model
   */ 
  interface WatchlistItemFieldRefs {
    readonly id: FieldRef<"WatchlistItem", 'String'>
    readonly subscriptionId: FieldRef<"WatchlistItem", 'String'>
    readonly type: FieldRef<"WatchlistItem", 'WatchlistType'>
    readonly value: FieldRef<"WatchlistItem", 'String'>
    readonly hash: FieldRef<"WatchlistItem", 'String'>
    readonly isActive: FieldRef<"WatchlistItem", 'Boolean'>
    readonly createdAt: FieldRef<"WatchlistItem", 'DateTime'>
    readonly updatedAt: FieldRef<"WatchlistItem", 'DateTime'>
  }
    

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

  /**
   * WatchlistItem findUniqueOrThrow
   */
  export type WatchlistItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * Filter, which WatchlistItem to fetch.
     */
    where: WatchlistItemWhereUniqueInput
  }

  /**
   * WatchlistItem findFirst
   */
  export type WatchlistItemFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * Filter, which WatchlistItem to fetch.
     */
    where?: WatchlistItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WatchlistItems to fetch.
     */
    orderBy?: WatchlistItemOrderByWithRelationInput | WatchlistItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for WatchlistItems.
     */
    cursor?: WatchlistItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WatchlistItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WatchlistItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WatchlistItems.
     */
    distinct?: WatchlistItemScalarFieldEnum | WatchlistItemScalarFieldEnum[]
  }

  /**
   * WatchlistItem findFirstOrThrow
   */
  export type WatchlistItemFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * Filter, which WatchlistItem to fetch.
     */
    where?: WatchlistItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WatchlistItems to fetch.
     */
    orderBy?: WatchlistItemOrderByWithRelationInput | WatchlistItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for WatchlistItems.
     */
    cursor?: WatchlistItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WatchlistItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WatchlistItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WatchlistItems.
     */
    distinct?: WatchlistItemScalarFieldEnum | WatchlistItemScalarFieldEnum[]
  }

  /**
   * WatchlistItem findMany
   */
  export type WatchlistItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * Filter, which WatchlistItems to fetch.
     */
    where?: WatchlistItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WatchlistItems to fetch.
     */
    orderBy?: WatchlistItemOrderByWithRelationInput | WatchlistItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WatchlistItems.
     */
    cursor?: WatchlistItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WatchlistItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WatchlistItems.
     */
    skip?: number
    distinct?: WatchlistItemScalarFieldEnum | WatchlistItemScalarFieldEnum[]
  }

  /**
   * WatchlistItem create
   */
  export type WatchlistItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * The data needed to create a WatchlistItem.
     */
    data: XOR<WatchlistItemCreateInput, WatchlistItemUncheckedCreateInput>
  }

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

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

  /**
   * WatchlistItem update
   */
  export type WatchlistItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * The data needed to update a WatchlistItem.
     */
    data: XOR<WatchlistItemUpdateInput, WatchlistItemUncheckedUpdateInput>
    /**
     * Choose, which WatchlistItem to update.
     */
    where: WatchlistItemWhereUniqueInput
  }

  /**
   * WatchlistItem updateMany
   */
  export type WatchlistItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WatchlistItems.
     */
    data: XOR<WatchlistItemUpdateManyMutationInput, WatchlistItemUncheckedUpdateManyInput>
    /**
     * Filter which WatchlistItems to update
     */
    where?: WatchlistItemWhereInput
  }

  /**
   * WatchlistItem upsert
   */
  export type WatchlistItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * The filter to search for the WatchlistItem to update in case it exists.
     */
    where: WatchlistItemWhereUniqueInput
    /**
     * In case the WatchlistItem found by the `where` argument doesn't exist, create a new WatchlistItem with this data.
     */
    create: XOR<WatchlistItemCreateInput, WatchlistItemUncheckedCreateInput>
    /**
     * In case the WatchlistItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WatchlistItemUpdateInput, WatchlistItemUncheckedUpdateInput>
  }

  /**
   * WatchlistItem delete
   */
  export type WatchlistItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    /**
     * Filter which WatchlistItem to delete.
     */
    where: WatchlistItemWhereUniqueInput
  }

  /**
   * WatchlistItem deleteMany
   */
  export type WatchlistItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WatchlistItems to delete
     */
    where?: WatchlistItemWhereInput
  }

  /**
   * WatchlistItem.exposures
   */
  export type WatchlistItem$exposuresArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    where?: ExposureWhereInput
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    cursor?: ExposureWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExposureScalarFieldEnum | ExposureScalarFieldEnum[]
  }

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


  /**
   * Model Exposure
   */

  export type AggregateExposure = {
    _count: ExposureCountAggregateOutputType | null
    _min: ExposureMinAggregateOutputType | null
    _max: ExposureMaxAggregateOutputType | null
  }

  export type ExposureMinAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    watchlistItemId: string | null
    source: $Enums.ExposureSource | null
    dataType: $Enums.WatchlistType | null
    identifier: string | null
    identifierHash: string | null
    severity: $Enums.ExposureSeverity | null
    isFirstTime: boolean | null
    detectedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ExposureMaxAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    watchlistItemId: string | null
    source: $Enums.ExposureSource | null
    dataType: $Enums.WatchlistType | null
    identifier: string | null
    identifierHash: string | null
    severity: $Enums.ExposureSeverity | null
    isFirstTime: boolean | null
    detectedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ExposureCountAggregateOutputType = {
    id: number
    subscriptionId: number
    watchlistItemId: number
    source: number
    dataType: number
    identifier: number
    identifierHash: number
    severity: number
    metadata: number
    isFirstTime: number
    detectedAt: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type ExposureMinAggregateInputType = {
    id?: true
    subscriptionId?: true
    watchlistItemId?: true
    source?: true
    dataType?: true
    identifier?: true
    identifierHash?: true
    severity?: true
    isFirstTime?: true
    detectedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ExposureMaxAggregateInputType = {
    id?: true
    subscriptionId?: true
    watchlistItemId?: true
    source?: true
    dataType?: true
    identifier?: true
    identifierHash?: true
    severity?: true
    isFirstTime?: true
    detectedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ExposureCountAggregateInputType = {
    id?: true
    subscriptionId?: true
    watchlistItemId?: true
    source?: true
    dataType?: true
    identifier?: true
    identifierHash?: true
    severity?: true
    metadata?: true
    isFirstTime?: true
    detectedAt?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type ExposureAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Exposure to aggregate.
     */
    where?: ExposureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exposures to fetch.
     */
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExposureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exposures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Exposures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Exposures
    **/
    _count?: true | ExposureCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExposureMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExposureMaxAggregateInputType
  }

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




  export type ExposureGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExposureWhereInput
    orderBy?: ExposureOrderByWithAggregationInput | ExposureOrderByWithAggregationInput[]
    by: ExposureScalarFieldEnum[] | ExposureScalarFieldEnum
    having?: ExposureScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExposureCountAggregateInputType | true
    _min?: ExposureMinAggregateInputType
    _max?: ExposureMaxAggregateInputType
  }

  export type ExposureGroupByOutputType = {
    id: string
    subscriptionId: string
    watchlistItemId: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity: $Enums.ExposureSeverity
    metadata: JsonValue | null
    isFirstTime: boolean
    detectedAt: Date
    createdAt: Date
    updatedAt: Date
    _count: ExposureCountAggregateOutputType | null
    _min: ExposureMinAggregateOutputType | null
    _max: ExposureMaxAggregateOutputType | null
  }

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


  export type ExposureSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    watchlistItemId?: boolean
    source?: boolean
    dataType?: boolean
    identifier?: boolean
    identifierHash?: boolean
    severity?: boolean
    metadata?: boolean
    isFirstTime?: boolean
    detectedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    watchlistItem?: boolean | Exposure$watchlistItemArgs<ExtArgs>
    alerts?: boolean | Exposure$alertsArgs<ExtArgs>
    _count?: boolean | ExposureCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["exposure"]>

  export type ExposureSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    watchlistItemId?: boolean
    source?: boolean
    dataType?: boolean
    identifier?: boolean
    identifierHash?: boolean
    severity?: boolean
    metadata?: boolean
    isFirstTime?: boolean
    detectedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    watchlistItem?: boolean | Exposure$watchlistItemArgs<ExtArgs>
  }, ExtArgs["result"]["exposure"]>

  export type ExposureSelectScalar = {
    id?: boolean
    subscriptionId?: boolean
    watchlistItemId?: boolean
    source?: boolean
    dataType?: boolean
    identifier?: boolean
    identifierHash?: boolean
    severity?: boolean
    metadata?: boolean
    isFirstTime?: boolean
    detectedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type ExposureInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    watchlistItem?: boolean | Exposure$watchlistItemArgs<ExtArgs>
    alerts?: boolean | Exposure$alertsArgs<ExtArgs>
    _count?: boolean | ExposureCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ExposureIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    watchlistItem?: boolean | Exposure$watchlistItemArgs<ExtArgs>
  }

  export type $ExposurePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Exposure"
    objects: {
      subscription: Prisma.$SubscriptionPayload<ExtArgs>
      watchlistItem: Prisma.$WatchlistItemPayload<ExtArgs> | null
      alerts: Prisma.$AlertPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      subscriptionId: string
      watchlistItemId: string | null
      source: $Enums.ExposureSource
      dataType: $Enums.WatchlistType
      identifier: string
      identifierHash: string
      severity: $Enums.ExposureSeverity
      metadata: Prisma.JsonValue | null
      isFirstTime: boolean
      detectedAt: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["exposure"]>
    composites: {}
  }

  type ExposureGetPayload<S extends boolean | null | undefined | ExposureDefaultArgs> = $Result.GetResult<Prisma.$ExposurePayload, S>

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

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

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

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

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

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

    /**
     * Create a Exposure.
     * @param {ExposureCreateArgs} args - Arguments to create a Exposure.
     * @example
     * // Create one Exposure
     * const Exposure = await prisma.exposure.create({
     *   data: {
     *     // ... data to create a Exposure
     *   }
     * })
     * 
     */
    create<T extends ExposureCreateArgs>(args: SelectSubset<T, ExposureCreateArgs<ExtArgs>>): Prisma__ExposureClient<$Result.GetResult<Prisma.$ExposurePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Exposure.
     * @param {ExposureDeleteArgs} args - Arguments to delete one Exposure.
     * @example
     * // Delete one Exposure
     * const Exposure = await prisma.exposure.delete({
     *   where: {
     *     // ... filter to delete one Exposure
     *   }
     * })
     * 
     */
    delete<T extends ExposureDeleteArgs>(args: SelectSubset<T, ExposureDeleteArgs<ExtArgs>>): Prisma__ExposureClient<$Result.GetResult<Prisma.$ExposurePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Exposure.
   * 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__ExposureClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    subscription<T extends SubscriptionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SubscriptionDefaultArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    watchlistItem<T extends Exposure$watchlistItemArgs<ExtArgs> = {}>(args?: Subset<T, Exposure$watchlistItemArgs<ExtArgs>>): Prisma__WatchlistItemClient<$Result.GetResult<Prisma.$WatchlistItemPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    alerts<T extends Exposure$alertsArgs<ExtArgs> = {}>(args?: Subset<T, Exposure$alertsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AlertPayload<ExtArgs>, T, "findMany"> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Exposure model
   */ 
  interface ExposureFieldRefs {
    readonly id: FieldRef<"Exposure", 'String'>
    readonly subscriptionId: FieldRef<"Exposure", 'String'>
    readonly watchlistItemId: FieldRef<"Exposure", 'String'>
    readonly source: FieldRef<"Exposure", 'ExposureSource'>
    readonly dataType: FieldRef<"Exposure", 'WatchlistType'>
    readonly identifier: FieldRef<"Exposure", 'String'>
    readonly identifierHash: FieldRef<"Exposure", 'String'>
    readonly severity: FieldRef<"Exposure", 'ExposureSeverity'>
    readonly metadata: FieldRef<"Exposure", 'Json'>
    readonly isFirstTime: FieldRef<"Exposure", 'Boolean'>
    readonly detectedAt: FieldRef<"Exposure", 'DateTime'>
    readonly createdAt: FieldRef<"Exposure", 'DateTime'>
    readonly updatedAt: FieldRef<"Exposure", 'DateTime'>
  }
    

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

  /**
   * Exposure findUniqueOrThrow
   */
  export type ExposureFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * Filter, which Exposure to fetch.
     */
    where: ExposureWhereUniqueInput
  }

  /**
   * Exposure findFirst
   */
  export type ExposureFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * Filter, which Exposure to fetch.
     */
    where?: ExposureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exposures to fetch.
     */
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Exposures.
     */
    cursor?: ExposureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exposures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Exposures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Exposures.
     */
    distinct?: ExposureScalarFieldEnum | ExposureScalarFieldEnum[]
  }

  /**
   * Exposure findFirstOrThrow
   */
  export type ExposureFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * Filter, which Exposure to fetch.
     */
    where?: ExposureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exposures to fetch.
     */
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Exposures.
     */
    cursor?: ExposureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exposures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Exposures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Exposures.
     */
    distinct?: ExposureScalarFieldEnum | ExposureScalarFieldEnum[]
  }

  /**
   * Exposure findMany
   */
  export type ExposureFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * Filter, which Exposures to fetch.
     */
    where?: ExposureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Exposures to fetch.
     */
    orderBy?: ExposureOrderByWithRelationInput | ExposureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Exposures.
     */
    cursor?: ExposureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Exposures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Exposures.
     */
    skip?: number
    distinct?: ExposureScalarFieldEnum | ExposureScalarFieldEnum[]
  }

  /**
   * Exposure create
   */
  export type ExposureCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * The data needed to create a Exposure.
     */
    data: XOR<ExposureCreateInput, ExposureUncheckedCreateInput>
  }

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

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

  /**
   * Exposure update
   */
  export type ExposureUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * The data needed to update a Exposure.
     */
    data: XOR<ExposureUpdateInput, ExposureUncheckedUpdateInput>
    /**
     * Choose, which Exposure to update.
     */
    where: ExposureWhereUniqueInput
  }

  /**
   * Exposure updateMany
   */
  export type ExposureUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Exposures.
     */
    data: XOR<ExposureUpdateManyMutationInput, ExposureUncheckedUpdateManyInput>
    /**
     * Filter which Exposures to update
     */
    where?: ExposureWhereInput
  }

  /**
   * Exposure upsert
   */
  export type ExposureUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * The filter to search for the Exposure to update in case it exists.
     */
    where: ExposureWhereUniqueInput
    /**
     * In case the Exposure found by the `where` argument doesn't exist, create a new Exposure with this data.
     */
    create: XOR<ExposureCreateInput, ExposureUncheckedCreateInput>
    /**
     * In case the Exposure was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExposureUpdateInput, ExposureUncheckedUpdateInput>
  }

  /**
   * Exposure delete
   */
  export type ExposureDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    /**
     * Filter which Exposure to delete.
     */
    where: ExposureWhereUniqueInput
  }

  /**
   * Exposure deleteMany
   */
  export type ExposureDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Exposures to delete
     */
    where?: ExposureWhereInput
  }

  /**
   * Exposure.watchlistItem
   */
  export type Exposure$watchlistItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WatchlistItem
     */
    select?: WatchlistItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WatchlistItemInclude<ExtArgs> | null
    where?: WatchlistItemWhereInput
  }

  /**
   * Exposure.alerts
   */
  export type Exposure$alertsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    where?: AlertWhereInput
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    cursor?: AlertWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

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


  /**
   * Model Alert
   */

  export type AggregateAlert = {
    _count: AlertCountAggregateOutputType | null
    _min: AlertMinAggregateOutputType | null
    _max: AlertMaxAggregateOutputType | null
  }

  export type AlertMinAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    userId: string | null
    exposureId: string | null
    type: $Enums.AlertType | null
    title: string | null
    message: string | null
    severity: $Enums.AlertSeverity | null
    isRead: boolean | null
    readAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AlertMaxAggregateOutputType = {
    id: string | null
    subscriptionId: string | null
    userId: string | null
    exposureId: string | null
    type: $Enums.AlertType | null
    title: string | null
    message: string | null
    severity: $Enums.AlertSeverity | null
    isRead: boolean | null
    readAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AlertCountAggregateOutputType = {
    id: number
    subscriptionId: number
    userId: number
    exposureId: number
    type: number
    title: number
    message: number
    severity: number
    isRead: number
    readAt: number
    channel: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type AlertMinAggregateInputType = {
    id?: true
    subscriptionId?: true
    userId?: true
    exposureId?: true
    type?: true
    title?: true
    message?: true
    severity?: true
    isRead?: true
    readAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AlertMaxAggregateInputType = {
    id?: true
    subscriptionId?: true
    userId?: true
    exposureId?: true
    type?: true
    title?: true
    message?: true
    severity?: true
    isRead?: true
    readAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AlertCountAggregateInputType = {
    id?: true
    subscriptionId?: true
    userId?: true
    exposureId?: true
    type?: true
    title?: true
    message?: true
    severity?: true
    isRead?: true
    readAt?: true
    channel?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type AlertAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Alert to aggregate.
     */
    where?: AlertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Alerts to fetch.
     */
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AlertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Alerts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Alerts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Alerts
    **/
    _count?: true | AlertCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AlertMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AlertMaxAggregateInputType
  }

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




  export type AlertGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AlertWhereInput
    orderBy?: AlertOrderByWithAggregationInput | AlertOrderByWithAggregationInput[]
    by: AlertScalarFieldEnum[] | AlertScalarFieldEnum
    having?: AlertScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AlertCountAggregateInputType | true
    _min?: AlertMinAggregateInputType
    _max?: AlertMaxAggregateInputType
  }

  export type AlertGroupByOutputType = {
    id: string
    subscriptionId: string
    userId: string
    exposureId: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity: $Enums.AlertSeverity
    isRead: boolean
    readAt: Date | null
    channel: $Enums.AlertChannel[]
    createdAt: Date
    updatedAt: Date
    _count: AlertCountAggregateOutputType | null
    _min: AlertMinAggregateOutputType | null
    _max: AlertMaxAggregateOutputType | null
  }

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


  export type AlertSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    userId?: boolean
    exposureId?: boolean
    type?: boolean
    title?: boolean
    message?: boolean
    severity?: boolean
    isRead?: boolean
    readAt?: boolean
    channel?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    exposure?: boolean | Alert$exposureArgs<ExtArgs>
  }, ExtArgs["result"]["alert"]>

  export type AlertSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subscriptionId?: boolean
    userId?: boolean
    exposureId?: boolean
    type?: boolean
    title?: boolean
    message?: boolean
    severity?: boolean
    isRead?: boolean
    readAt?: boolean
    channel?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    exposure?: boolean | Alert$exposureArgs<ExtArgs>
  }, ExtArgs["result"]["alert"]>

  export type AlertSelectScalar = {
    id?: boolean
    subscriptionId?: boolean
    userId?: boolean
    exposureId?: boolean
    type?: boolean
    title?: boolean
    message?: boolean
    severity?: boolean
    isRead?: boolean
    readAt?: boolean
    channel?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type AlertInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    exposure?: boolean | Alert$exposureArgs<ExtArgs>
  }
  export type AlertIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    subscription?: boolean | SubscriptionDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    exposure?: boolean | Alert$exposureArgs<ExtArgs>
  }

  export type $AlertPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Alert"
    objects: {
      subscription: Prisma.$SubscriptionPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
      exposure: Prisma.$ExposurePayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      subscriptionId: string
      userId: string
      exposureId: string | null
      type: $Enums.AlertType
      title: string
      message: string
      severity: $Enums.AlertSeverity
      isRead: boolean
      readAt: Date | null
      channel: $Enums.AlertChannel[]
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["alert"]>
    composites: {}
  }

  type AlertGetPayload<S extends boolean | null | undefined | AlertDefaultArgs> = $Result.GetResult<Prisma.$AlertPayload, S>

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

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

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

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

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

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

    /**
     * Create a Alert.
     * @param {AlertCreateArgs} args - Arguments to create a Alert.
     * @example
     * // Create one Alert
     * const Alert = await prisma.alert.create({
     *   data: {
     *     // ... data to create a Alert
     *   }
     * })
     * 
     */
    create<T extends AlertCreateArgs>(args: SelectSubset<T, AlertCreateArgs<ExtArgs>>): Prisma__AlertClient<$Result.GetResult<Prisma.$AlertPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Alert.
     * @param {AlertDeleteArgs} args - Arguments to delete one Alert.
     * @example
     * // Delete one Alert
     * const Alert = await prisma.alert.delete({
     *   where: {
     *     // ... filter to delete one Alert
     *   }
     * })
     * 
     */
    delete<T extends AlertDeleteArgs>(args: SelectSubset<T, AlertDeleteArgs<ExtArgs>>): Prisma__AlertClient<$Result.GetResult<Prisma.$AlertPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the Alert model
   */ 
  interface AlertFieldRefs {
    readonly id: FieldRef<"Alert", 'String'>
    readonly subscriptionId: FieldRef<"Alert", 'String'>
    readonly userId: FieldRef<"Alert", 'String'>
    readonly exposureId: FieldRef<"Alert", 'String'>
    readonly type: FieldRef<"Alert", 'AlertType'>
    readonly title: FieldRef<"Alert", 'String'>
    readonly message: FieldRef<"Alert", 'String'>
    readonly severity: FieldRef<"Alert", 'AlertSeverity'>
    readonly isRead: FieldRef<"Alert", 'Boolean'>
    readonly readAt: FieldRef<"Alert", 'DateTime'>
    readonly channel: FieldRef<"Alert", 'AlertChannel[]'>
    readonly createdAt: FieldRef<"Alert", 'DateTime'>
    readonly updatedAt: FieldRef<"Alert", 'DateTime'>
  }
    

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

  /**
   * Alert findUniqueOrThrow
   */
  export type AlertFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * Filter, which Alert to fetch.
     */
    where: AlertWhereUniqueInput
  }

  /**
   * Alert findFirst
   */
  export type AlertFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * Filter, which Alert to fetch.
     */
    where?: AlertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Alerts to fetch.
     */
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Alerts.
     */
    cursor?: AlertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Alerts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Alerts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Alerts.
     */
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

  /**
   * Alert findFirstOrThrow
   */
  export type AlertFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * Filter, which Alert to fetch.
     */
    where?: AlertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Alerts to fetch.
     */
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Alerts.
     */
    cursor?: AlertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Alerts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Alerts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Alerts.
     */
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

  /**
   * Alert findMany
   */
  export type AlertFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * Filter, which Alerts to fetch.
     */
    where?: AlertWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Alerts to fetch.
     */
    orderBy?: AlertOrderByWithRelationInput | AlertOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Alerts.
     */
    cursor?: AlertWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Alerts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Alerts.
     */
    skip?: number
    distinct?: AlertScalarFieldEnum | AlertScalarFieldEnum[]
  }

  /**
   * Alert create
   */
  export type AlertCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * The data needed to create a Alert.
     */
    data: XOR<AlertCreateInput, AlertUncheckedCreateInput>
  }

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

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

  /**
   * Alert update
   */
  export type AlertUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * The data needed to update a Alert.
     */
    data: XOR<AlertUpdateInput, AlertUncheckedUpdateInput>
    /**
     * Choose, which Alert to update.
     */
    where: AlertWhereUniqueInput
  }

  /**
   * Alert updateMany
   */
  export type AlertUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Alerts.
     */
    data: XOR<AlertUpdateManyMutationInput, AlertUncheckedUpdateManyInput>
    /**
     * Filter which Alerts to update
     */
    where?: AlertWhereInput
  }

  /**
   * Alert upsert
   */
  export type AlertUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * The filter to search for the Alert to update in case it exists.
     */
    where: AlertWhereUniqueInput
    /**
     * In case the Alert found by the `where` argument doesn't exist, create a new Alert with this data.
     */
    create: XOR<AlertCreateInput, AlertUncheckedCreateInput>
    /**
     * In case the Alert was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AlertUpdateInput, AlertUncheckedUpdateInput>
  }

  /**
   * Alert delete
   */
  export type AlertDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Alert
     */
    select?: AlertSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AlertInclude<ExtArgs> | null
    /**
     * Filter which Alert to delete.
     */
    where: AlertWhereUniqueInput
  }

  /**
   * Alert deleteMany
   */
  export type AlertDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Alerts to delete
     */
    where?: AlertWhereInput
  }

  /**
   * Alert.exposure
   */
  export type Alert$exposureArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Exposure
     */
    select?: ExposureSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExposureInclude<ExtArgs> | null
    where?: ExposureWhereInput
  }

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


  /**
   * Model VoiceEnrollment
   */

  export type AggregateVoiceEnrollment = {
    _count: VoiceEnrollmentCountAggregateOutputType | null
    _min: VoiceEnrollmentMinAggregateOutputType | null
    _max: VoiceEnrollmentMaxAggregateOutputType | null
  }

  export type VoiceEnrollmentMinAggregateOutputType = {
    id: string | null
    userId: string | null
    name: string | null
    voiceHash: string | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type VoiceEnrollmentMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    name: string | null
    voiceHash: string | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type VoiceEnrollmentCountAggregateOutputType = {
    id: number
    userId: number
    name: number
    voiceHash: number
    audioMetadata: number
    isActive: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type VoiceEnrollmentMinAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    voiceHash?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type VoiceEnrollmentMaxAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    voiceHash?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type VoiceEnrollmentCountAggregateInputType = {
    id?: true
    userId?: true
    name?: true
    voiceHash?: true
    audioMetadata?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type VoiceEnrollmentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VoiceEnrollment to aggregate.
     */
    where?: VoiceEnrollmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceEnrollments to fetch.
     */
    orderBy?: VoiceEnrollmentOrderByWithRelationInput | VoiceEnrollmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: VoiceEnrollmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceEnrollments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceEnrollments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned VoiceEnrollments
    **/
    _count?: true | VoiceEnrollmentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VoiceEnrollmentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VoiceEnrollmentMaxAggregateInputType
  }

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




  export type VoiceEnrollmentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VoiceEnrollmentWhereInput
    orderBy?: VoiceEnrollmentOrderByWithAggregationInput | VoiceEnrollmentOrderByWithAggregationInput[]
    by: VoiceEnrollmentScalarFieldEnum[] | VoiceEnrollmentScalarFieldEnum
    having?: VoiceEnrollmentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VoiceEnrollmentCountAggregateInputType | true
    _min?: VoiceEnrollmentMinAggregateInputType
    _max?: VoiceEnrollmentMaxAggregateInputType
  }

  export type VoiceEnrollmentGroupByOutputType = {
    id: string
    userId: string
    name: string
    voiceHash: string
    audioMetadata: JsonValue | null
    isActive: boolean
    createdAt: Date
    updatedAt: Date
    _count: VoiceEnrollmentCountAggregateOutputType | null
    _min: VoiceEnrollmentMinAggregateOutputType | null
    _max: VoiceEnrollmentMaxAggregateOutputType | null
  }

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


  export type VoiceEnrollmentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    voiceHash?: boolean
    audioMetadata?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    analyses?: boolean | VoiceEnrollment$analysesArgs<ExtArgs>
    _count?: boolean | VoiceEnrollmentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["voiceEnrollment"]>

  export type VoiceEnrollmentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    name?: boolean
    voiceHash?: boolean
    audioMetadata?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["voiceEnrollment"]>

  export type VoiceEnrollmentSelectScalar = {
    id?: boolean
    userId?: boolean
    name?: boolean
    voiceHash?: boolean
    audioMetadata?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type VoiceEnrollmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    analyses?: boolean | VoiceEnrollment$analysesArgs<ExtArgs>
    _count?: boolean | VoiceEnrollmentCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type VoiceEnrollmentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $VoiceEnrollmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "VoiceEnrollment"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      analyses: Prisma.$VoiceAnalysisPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      name: string
      voiceHash: string
      audioMetadata: Prisma.JsonValue | null
      isActive: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["voiceEnrollment"]>
    composites: {}
  }

  type VoiceEnrollmentGetPayload<S extends boolean | null | undefined | VoiceEnrollmentDefaultArgs> = $Result.GetResult<Prisma.$VoiceEnrollmentPayload, S>

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

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

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

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

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

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

    /**
     * Create a VoiceEnrollment.
     * @param {VoiceEnrollmentCreateArgs} args - Arguments to create a VoiceEnrollment.
     * @example
     * // Create one VoiceEnrollment
     * const VoiceEnrollment = await prisma.voiceEnrollment.create({
     *   data: {
     *     // ... data to create a VoiceEnrollment
     *   }
     * })
     * 
     */
    create<T extends VoiceEnrollmentCreateArgs>(args: SelectSubset<T, VoiceEnrollmentCreateArgs<ExtArgs>>): Prisma__VoiceEnrollmentClient<$Result.GetResult<Prisma.$VoiceEnrollmentPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a VoiceEnrollment.
     * @param {VoiceEnrollmentDeleteArgs} args - Arguments to delete one VoiceEnrollment.
     * @example
     * // Delete one VoiceEnrollment
     * const VoiceEnrollment = await prisma.voiceEnrollment.delete({
     *   where: {
     *     // ... filter to delete one VoiceEnrollment
     *   }
     * })
     * 
     */
    delete<T extends VoiceEnrollmentDeleteArgs>(args: SelectSubset<T, VoiceEnrollmentDeleteArgs<ExtArgs>>): Prisma__VoiceEnrollmentClient<$Result.GetResult<Prisma.$VoiceEnrollmentPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the VoiceEnrollment model
   */ 
  interface VoiceEnrollmentFieldRefs {
    readonly id: FieldRef<"VoiceEnrollment", 'String'>
    readonly userId: FieldRef<"VoiceEnrollment", 'String'>
    readonly name: FieldRef<"VoiceEnrollment", 'String'>
    readonly voiceHash: FieldRef<"VoiceEnrollment", 'String'>
    readonly audioMetadata: FieldRef<"VoiceEnrollment", 'Json'>
    readonly isActive: FieldRef<"VoiceEnrollment", 'Boolean'>
    readonly createdAt: FieldRef<"VoiceEnrollment", 'DateTime'>
    readonly updatedAt: FieldRef<"VoiceEnrollment", 'DateTime'>
  }
    

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

  /**
   * VoiceEnrollment findUniqueOrThrow
   */
  export type VoiceEnrollmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * Filter, which VoiceEnrollment to fetch.
     */
    where: VoiceEnrollmentWhereUniqueInput
  }

  /**
   * VoiceEnrollment findFirst
   */
  export type VoiceEnrollmentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * Filter, which VoiceEnrollment to fetch.
     */
    where?: VoiceEnrollmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceEnrollments to fetch.
     */
    orderBy?: VoiceEnrollmentOrderByWithRelationInput | VoiceEnrollmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for VoiceEnrollments.
     */
    cursor?: VoiceEnrollmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceEnrollments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceEnrollments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of VoiceEnrollments.
     */
    distinct?: VoiceEnrollmentScalarFieldEnum | VoiceEnrollmentScalarFieldEnum[]
  }

  /**
   * VoiceEnrollment findFirstOrThrow
   */
  export type VoiceEnrollmentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * Filter, which VoiceEnrollment to fetch.
     */
    where?: VoiceEnrollmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceEnrollments to fetch.
     */
    orderBy?: VoiceEnrollmentOrderByWithRelationInput | VoiceEnrollmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for VoiceEnrollments.
     */
    cursor?: VoiceEnrollmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceEnrollments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceEnrollments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of VoiceEnrollments.
     */
    distinct?: VoiceEnrollmentScalarFieldEnum | VoiceEnrollmentScalarFieldEnum[]
  }

  /**
   * VoiceEnrollment findMany
   */
  export type VoiceEnrollmentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * Filter, which VoiceEnrollments to fetch.
     */
    where?: VoiceEnrollmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceEnrollments to fetch.
     */
    orderBy?: VoiceEnrollmentOrderByWithRelationInput | VoiceEnrollmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing VoiceEnrollments.
     */
    cursor?: VoiceEnrollmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceEnrollments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceEnrollments.
     */
    skip?: number
    distinct?: VoiceEnrollmentScalarFieldEnum | VoiceEnrollmentScalarFieldEnum[]
  }

  /**
   * VoiceEnrollment create
   */
  export type VoiceEnrollmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * The data needed to create a VoiceEnrollment.
     */
    data: XOR<VoiceEnrollmentCreateInput, VoiceEnrollmentUncheckedCreateInput>
  }

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

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

  /**
   * VoiceEnrollment update
   */
  export type VoiceEnrollmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * The data needed to update a VoiceEnrollment.
     */
    data: XOR<VoiceEnrollmentUpdateInput, VoiceEnrollmentUncheckedUpdateInput>
    /**
     * Choose, which VoiceEnrollment to update.
     */
    where: VoiceEnrollmentWhereUniqueInput
  }

  /**
   * VoiceEnrollment updateMany
   */
  export type VoiceEnrollmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update VoiceEnrollments.
     */
    data: XOR<VoiceEnrollmentUpdateManyMutationInput, VoiceEnrollmentUncheckedUpdateManyInput>
    /**
     * Filter which VoiceEnrollments to update
     */
    where?: VoiceEnrollmentWhereInput
  }

  /**
   * VoiceEnrollment upsert
   */
  export type VoiceEnrollmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * The filter to search for the VoiceEnrollment to update in case it exists.
     */
    where: VoiceEnrollmentWhereUniqueInput
    /**
     * In case the VoiceEnrollment found by the `where` argument doesn't exist, create a new VoiceEnrollment with this data.
     */
    create: XOR<VoiceEnrollmentCreateInput, VoiceEnrollmentUncheckedCreateInput>
    /**
     * In case the VoiceEnrollment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VoiceEnrollmentUpdateInput, VoiceEnrollmentUncheckedUpdateInput>
  }

  /**
   * VoiceEnrollment delete
   */
  export type VoiceEnrollmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    /**
     * Filter which VoiceEnrollment to delete.
     */
    where: VoiceEnrollmentWhereUniqueInput
  }

  /**
   * VoiceEnrollment deleteMany
   */
  export type VoiceEnrollmentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VoiceEnrollments to delete
     */
    where?: VoiceEnrollmentWhereInput
  }

  /**
   * VoiceEnrollment.analyses
   */
  export type VoiceEnrollment$analysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    where?: VoiceAnalysisWhereInput
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    cursor?: VoiceAnalysisWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VoiceAnalysisScalarFieldEnum | VoiceAnalysisScalarFieldEnum[]
  }

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


  /**
   * Model VoiceAnalysis
   */

  export type AggregateVoiceAnalysis = {
    _count: VoiceAnalysisCountAggregateOutputType | null
    _avg: VoiceAnalysisAvgAggregateOutputType | null
    _sum: VoiceAnalysisSumAggregateOutputType | null
    _min: VoiceAnalysisMinAggregateOutputType | null
    _max: VoiceAnalysisMaxAggregateOutputType | null
  }

  export type VoiceAnalysisAvgAggregateOutputType = {
    confidence: number | null
  }

  export type VoiceAnalysisSumAggregateOutputType = {
    confidence: number | null
  }

  export type VoiceAnalysisMinAggregateOutputType = {
    id: string | null
    enrollmentId: string | null
    userId: string | null
    audioHash: string | null
    isSynthetic: boolean | null
    confidence: number | null
    audioUrl: string | null
    createdAt: Date | null
  }

  export type VoiceAnalysisMaxAggregateOutputType = {
    id: string | null
    enrollmentId: string | null
    userId: string | null
    audioHash: string | null
    isSynthetic: boolean | null
    confidence: number | null
    audioUrl: string | null
    createdAt: Date | null
  }

  export type VoiceAnalysisCountAggregateOutputType = {
    id: number
    enrollmentId: number
    userId: number
    audioHash: number
    isSynthetic: number
    confidence: number
    analysisResult: number
    audioUrl: number
    createdAt: number
    _all: number
  }


  export type VoiceAnalysisAvgAggregateInputType = {
    confidence?: true
  }

  export type VoiceAnalysisSumAggregateInputType = {
    confidence?: true
  }

  export type VoiceAnalysisMinAggregateInputType = {
    id?: true
    enrollmentId?: true
    userId?: true
    audioHash?: true
    isSynthetic?: true
    confidence?: true
    audioUrl?: true
    createdAt?: true
  }

  export type VoiceAnalysisMaxAggregateInputType = {
    id?: true
    enrollmentId?: true
    userId?: true
    audioHash?: true
    isSynthetic?: true
    confidence?: true
    audioUrl?: true
    createdAt?: true
  }

  export type VoiceAnalysisCountAggregateInputType = {
    id?: true
    enrollmentId?: true
    userId?: true
    audioHash?: true
    isSynthetic?: true
    confidence?: true
    analysisResult?: true
    audioUrl?: true
    createdAt?: true
    _all?: true
  }

  export type VoiceAnalysisAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VoiceAnalysis to aggregate.
     */
    where?: VoiceAnalysisWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceAnalyses to fetch.
     */
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: VoiceAnalysisWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceAnalyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceAnalyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned VoiceAnalyses
    **/
    _count?: true | VoiceAnalysisCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: VoiceAnalysisAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: VoiceAnalysisSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VoiceAnalysisMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VoiceAnalysisMaxAggregateInputType
  }

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




  export type VoiceAnalysisGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VoiceAnalysisWhereInput
    orderBy?: VoiceAnalysisOrderByWithAggregationInput | VoiceAnalysisOrderByWithAggregationInput[]
    by: VoiceAnalysisScalarFieldEnum[] | VoiceAnalysisScalarFieldEnum
    having?: VoiceAnalysisScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VoiceAnalysisCountAggregateInputType | true
    _avg?: VoiceAnalysisAvgAggregateInputType
    _sum?: VoiceAnalysisSumAggregateInputType
    _min?: VoiceAnalysisMinAggregateInputType
    _max?: VoiceAnalysisMaxAggregateInputType
  }

  export type VoiceAnalysisGroupByOutputType = {
    id: string
    enrollmentId: string | null
    userId: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonValue
    audioUrl: string
    createdAt: Date
    _count: VoiceAnalysisCountAggregateOutputType | null
    _avg: VoiceAnalysisAvgAggregateOutputType | null
    _sum: VoiceAnalysisSumAggregateOutputType | null
    _min: VoiceAnalysisMinAggregateOutputType | null
    _max: VoiceAnalysisMaxAggregateOutputType | null
  }

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


  export type VoiceAnalysisSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    enrollmentId?: boolean
    userId?: boolean
    audioHash?: boolean
    isSynthetic?: boolean
    confidence?: boolean
    analysisResult?: boolean
    audioUrl?: boolean
    createdAt?: boolean
    enrollment?: boolean | VoiceAnalysis$enrollmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["voiceAnalysis"]>

  export type VoiceAnalysisSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    enrollmentId?: boolean
    userId?: boolean
    audioHash?: boolean
    isSynthetic?: boolean
    confidence?: boolean
    analysisResult?: boolean
    audioUrl?: boolean
    createdAt?: boolean
    enrollment?: boolean | VoiceAnalysis$enrollmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["voiceAnalysis"]>

  export type VoiceAnalysisSelectScalar = {
    id?: boolean
    enrollmentId?: boolean
    userId?: boolean
    audioHash?: boolean
    isSynthetic?: boolean
    confidence?: boolean
    analysisResult?: boolean
    audioUrl?: boolean
    createdAt?: boolean
  }

  export type VoiceAnalysisInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    enrollment?: boolean | VoiceAnalysis$enrollmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type VoiceAnalysisIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    enrollment?: boolean | VoiceAnalysis$enrollmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $VoiceAnalysisPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "VoiceAnalysis"
    objects: {
      enrollment: Prisma.$VoiceEnrollmentPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      enrollmentId: string | null
      userId: string
      audioHash: string
      isSynthetic: boolean
      confidence: number
      analysisResult: Prisma.JsonValue
      audioUrl: string
      createdAt: Date
    }, ExtArgs["result"]["voiceAnalysis"]>
    composites: {}
  }

  type VoiceAnalysisGetPayload<S extends boolean | null | undefined | VoiceAnalysisDefaultArgs> = $Result.GetResult<Prisma.$VoiceAnalysisPayload, S>

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

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

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

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

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

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

    /**
     * Create a VoiceAnalysis.
     * @param {VoiceAnalysisCreateArgs} args - Arguments to create a VoiceAnalysis.
     * @example
     * // Create one VoiceAnalysis
     * const VoiceAnalysis = await prisma.voiceAnalysis.create({
     *   data: {
     *     // ... data to create a VoiceAnalysis
     *   }
     * })
     * 
     */
    create<T extends VoiceAnalysisCreateArgs>(args: SelectSubset<T, VoiceAnalysisCreateArgs<ExtArgs>>): Prisma__VoiceAnalysisClient<$Result.GetResult<Prisma.$VoiceAnalysisPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a VoiceAnalysis.
     * @param {VoiceAnalysisDeleteArgs} args - Arguments to delete one VoiceAnalysis.
     * @example
     * // Delete one VoiceAnalysis
     * const VoiceAnalysis = await prisma.voiceAnalysis.delete({
     *   where: {
     *     // ... filter to delete one VoiceAnalysis
     *   }
     * })
     * 
     */
    delete<T extends VoiceAnalysisDeleteArgs>(args: SelectSubset<T, VoiceAnalysisDeleteArgs<ExtArgs>>): Prisma__VoiceAnalysisClient<$Result.GetResult<Prisma.$VoiceAnalysisPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the VoiceAnalysis model
   */ 
  interface VoiceAnalysisFieldRefs {
    readonly id: FieldRef<"VoiceAnalysis", 'String'>
    readonly enrollmentId: FieldRef<"VoiceAnalysis", 'String'>
    readonly userId: FieldRef<"VoiceAnalysis", 'String'>
    readonly audioHash: FieldRef<"VoiceAnalysis", 'String'>
    readonly isSynthetic: FieldRef<"VoiceAnalysis", 'Boolean'>
    readonly confidence: FieldRef<"VoiceAnalysis", 'Float'>
    readonly analysisResult: FieldRef<"VoiceAnalysis", 'Json'>
    readonly audioUrl: FieldRef<"VoiceAnalysis", 'String'>
    readonly createdAt: FieldRef<"VoiceAnalysis", 'DateTime'>
  }
    

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

  /**
   * VoiceAnalysis findUniqueOrThrow
   */
  export type VoiceAnalysisFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * Filter, which VoiceAnalysis to fetch.
     */
    where: VoiceAnalysisWhereUniqueInput
  }

  /**
   * VoiceAnalysis findFirst
   */
  export type VoiceAnalysisFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * Filter, which VoiceAnalysis to fetch.
     */
    where?: VoiceAnalysisWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceAnalyses to fetch.
     */
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for VoiceAnalyses.
     */
    cursor?: VoiceAnalysisWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceAnalyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceAnalyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of VoiceAnalyses.
     */
    distinct?: VoiceAnalysisScalarFieldEnum | VoiceAnalysisScalarFieldEnum[]
  }

  /**
   * VoiceAnalysis findFirstOrThrow
   */
  export type VoiceAnalysisFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * Filter, which VoiceAnalysis to fetch.
     */
    where?: VoiceAnalysisWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceAnalyses to fetch.
     */
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for VoiceAnalyses.
     */
    cursor?: VoiceAnalysisWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceAnalyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceAnalyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of VoiceAnalyses.
     */
    distinct?: VoiceAnalysisScalarFieldEnum | VoiceAnalysisScalarFieldEnum[]
  }

  /**
   * VoiceAnalysis findMany
   */
  export type VoiceAnalysisFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * Filter, which VoiceAnalyses to fetch.
     */
    where?: VoiceAnalysisWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VoiceAnalyses to fetch.
     */
    orderBy?: VoiceAnalysisOrderByWithRelationInput | VoiceAnalysisOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing VoiceAnalyses.
     */
    cursor?: VoiceAnalysisWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VoiceAnalyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VoiceAnalyses.
     */
    skip?: number
    distinct?: VoiceAnalysisScalarFieldEnum | VoiceAnalysisScalarFieldEnum[]
  }

  /**
   * VoiceAnalysis create
   */
  export type VoiceAnalysisCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * The data needed to create a VoiceAnalysis.
     */
    data: XOR<VoiceAnalysisCreateInput, VoiceAnalysisUncheckedCreateInput>
  }

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

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

  /**
   * VoiceAnalysis update
   */
  export type VoiceAnalysisUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * The data needed to update a VoiceAnalysis.
     */
    data: XOR<VoiceAnalysisUpdateInput, VoiceAnalysisUncheckedUpdateInput>
    /**
     * Choose, which VoiceAnalysis to update.
     */
    where: VoiceAnalysisWhereUniqueInput
  }

  /**
   * VoiceAnalysis updateMany
   */
  export type VoiceAnalysisUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update VoiceAnalyses.
     */
    data: XOR<VoiceAnalysisUpdateManyMutationInput, VoiceAnalysisUncheckedUpdateManyInput>
    /**
     * Filter which VoiceAnalyses to update
     */
    where?: VoiceAnalysisWhereInput
  }

  /**
   * VoiceAnalysis upsert
   */
  export type VoiceAnalysisUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * The filter to search for the VoiceAnalysis to update in case it exists.
     */
    where: VoiceAnalysisWhereUniqueInput
    /**
     * In case the VoiceAnalysis found by the `where` argument doesn't exist, create a new VoiceAnalysis with this data.
     */
    create: XOR<VoiceAnalysisCreateInput, VoiceAnalysisUncheckedCreateInput>
    /**
     * In case the VoiceAnalysis was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VoiceAnalysisUpdateInput, VoiceAnalysisUncheckedUpdateInput>
  }

  /**
   * VoiceAnalysis delete
   */
  export type VoiceAnalysisDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceAnalysis
     */
    select?: VoiceAnalysisSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceAnalysisInclude<ExtArgs> | null
    /**
     * Filter which VoiceAnalysis to delete.
     */
    where: VoiceAnalysisWhereUniqueInput
  }

  /**
   * VoiceAnalysis deleteMany
   */
  export type VoiceAnalysisDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VoiceAnalyses to delete
     */
    where?: VoiceAnalysisWhereInput
  }

  /**
   * VoiceAnalysis.enrollment
   */
  export type VoiceAnalysis$enrollmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VoiceEnrollment
     */
    select?: VoiceEnrollmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VoiceEnrollmentInclude<ExtArgs> | null
    where?: VoiceEnrollmentWhereInput
  }

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


  /**
   * Model SpamFeedback
   */

  export type AggregateSpamFeedback = {
    _count: SpamFeedbackCountAggregateOutputType | null
    _avg: SpamFeedbackAvgAggregateOutputType | null
    _sum: SpamFeedbackSumAggregateOutputType | null
    _min: SpamFeedbackMinAggregateOutputType | null
    _max: SpamFeedbackMaxAggregateOutputType | null
  }

  export type SpamFeedbackAvgAggregateOutputType = {
    confidence: number | null
  }

  export type SpamFeedbackSumAggregateOutputType = {
    confidence: number | null
  }

  export type SpamFeedbackMinAggregateOutputType = {
    id: string | null
    userId: string | null
    phoneNumber: string | null
    phoneNumberHash: string | null
    isSpam: boolean | null
    confidence: number | null
    feedbackType: $Enums.FeedbackType | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SpamFeedbackMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    phoneNumber: string | null
    phoneNumberHash: string | null
    isSpam: boolean | null
    confidence: number | null
    feedbackType: $Enums.FeedbackType | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SpamFeedbackCountAggregateOutputType = {
    id: number
    userId: number
    phoneNumber: number
    phoneNumberHash: number
    isSpam: number
    confidence: number
    feedbackType: number
    metadata: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SpamFeedbackAvgAggregateInputType = {
    confidence?: true
  }

  export type SpamFeedbackSumAggregateInputType = {
    confidence?: true
  }

  export type SpamFeedbackMinAggregateInputType = {
    id?: true
    userId?: true
    phoneNumber?: true
    phoneNumberHash?: true
    isSpam?: true
    confidence?: true
    feedbackType?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SpamFeedbackMaxAggregateInputType = {
    id?: true
    userId?: true
    phoneNumber?: true
    phoneNumberHash?: true
    isSpam?: true
    confidence?: true
    feedbackType?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SpamFeedbackCountAggregateInputType = {
    id?: true
    userId?: true
    phoneNumber?: true
    phoneNumberHash?: true
    isSpam?: true
    confidence?: true
    feedbackType?: true
    metadata?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SpamFeedbackAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SpamFeedback to aggregate.
     */
    where?: SpamFeedbackWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamFeedbacks to fetch.
     */
    orderBy?: SpamFeedbackOrderByWithRelationInput | SpamFeedbackOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SpamFeedbackWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamFeedbacks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamFeedbacks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SpamFeedbacks
    **/
    _count?: true | SpamFeedbackCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SpamFeedbackAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SpamFeedbackSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SpamFeedbackMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SpamFeedbackMaxAggregateInputType
  }

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




  export type SpamFeedbackGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SpamFeedbackWhereInput
    orderBy?: SpamFeedbackOrderByWithAggregationInput | SpamFeedbackOrderByWithAggregationInput[]
    by: SpamFeedbackScalarFieldEnum[] | SpamFeedbackScalarFieldEnum
    having?: SpamFeedbackScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SpamFeedbackCountAggregateInputType | true
    _avg?: SpamFeedbackAvgAggregateInputType
    _sum?: SpamFeedbackSumAggregateInputType
    _min?: SpamFeedbackMinAggregateInputType
    _max?: SpamFeedbackMaxAggregateInputType
  }

  export type SpamFeedbackGroupByOutputType = {
    id: string
    userId: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence: number | null
    feedbackType: $Enums.FeedbackType
    metadata: JsonValue | null
    createdAt: Date
    updatedAt: Date
    _count: SpamFeedbackCountAggregateOutputType | null
    _avg: SpamFeedbackAvgAggregateOutputType | null
    _sum: SpamFeedbackSumAggregateOutputType | null
    _min: SpamFeedbackMinAggregateOutputType | null
    _max: SpamFeedbackMaxAggregateOutputType | null
  }

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


  export type SpamFeedbackSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    phoneNumber?: boolean
    phoneNumberHash?: boolean
    isSpam?: boolean
    confidence?: boolean
    feedbackType?: boolean
    metadata?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["spamFeedback"]>

  export type SpamFeedbackSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    phoneNumber?: boolean
    phoneNumberHash?: boolean
    isSpam?: boolean
    confidence?: boolean
    feedbackType?: boolean
    metadata?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["spamFeedback"]>

  export type SpamFeedbackSelectScalar = {
    id?: boolean
    userId?: boolean
    phoneNumber?: boolean
    phoneNumberHash?: boolean
    isSpam?: boolean
    confidence?: boolean
    feedbackType?: boolean
    metadata?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

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

  export type $SpamFeedbackPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SpamFeedback"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      phoneNumber: string
      phoneNumberHash: string
      isSpam: boolean
      confidence: number | null
      feedbackType: $Enums.FeedbackType
      metadata: Prisma.JsonValue | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["spamFeedback"]>
    composites: {}
  }

  type SpamFeedbackGetPayload<S extends boolean | null | undefined | SpamFeedbackDefaultArgs> = $Result.GetResult<Prisma.$SpamFeedbackPayload, S>

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

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

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

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

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

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

    /**
     * Create a SpamFeedback.
     * @param {SpamFeedbackCreateArgs} args - Arguments to create a SpamFeedback.
     * @example
     * // Create one SpamFeedback
     * const SpamFeedback = await prisma.spamFeedback.create({
     *   data: {
     *     // ... data to create a SpamFeedback
     *   }
     * })
     * 
     */
    create<T extends SpamFeedbackCreateArgs>(args: SelectSubset<T, SpamFeedbackCreateArgs<ExtArgs>>): Prisma__SpamFeedbackClient<$Result.GetResult<Prisma.$SpamFeedbackPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a SpamFeedback.
     * @param {SpamFeedbackDeleteArgs} args - Arguments to delete one SpamFeedback.
     * @example
     * // Delete one SpamFeedback
     * const SpamFeedback = await prisma.spamFeedback.delete({
     *   where: {
     *     // ... filter to delete one SpamFeedback
     *   }
     * })
     * 
     */
    delete<T extends SpamFeedbackDeleteArgs>(args: SelectSubset<T, SpamFeedbackDeleteArgs<ExtArgs>>): Prisma__SpamFeedbackClient<$Result.GetResult<Prisma.$SpamFeedbackPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the SpamFeedback model
   */ 
  interface SpamFeedbackFieldRefs {
    readonly id: FieldRef<"SpamFeedback", 'String'>
    readonly userId: FieldRef<"SpamFeedback", 'String'>
    readonly phoneNumber: FieldRef<"SpamFeedback", 'String'>
    readonly phoneNumberHash: FieldRef<"SpamFeedback", 'String'>
    readonly isSpam: FieldRef<"SpamFeedback", 'Boolean'>
    readonly confidence: FieldRef<"SpamFeedback", 'Float'>
    readonly feedbackType: FieldRef<"SpamFeedback", 'FeedbackType'>
    readonly metadata: FieldRef<"SpamFeedback", 'Json'>
    readonly createdAt: FieldRef<"SpamFeedback", 'DateTime'>
    readonly updatedAt: FieldRef<"SpamFeedback", 'DateTime'>
  }
    

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

  /**
   * SpamFeedback findUniqueOrThrow
   */
  export type SpamFeedbackFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * Filter, which SpamFeedback to fetch.
     */
    where: SpamFeedbackWhereUniqueInput
  }

  /**
   * SpamFeedback findFirst
   */
  export type SpamFeedbackFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * Filter, which SpamFeedback to fetch.
     */
    where?: SpamFeedbackWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamFeedbacks to fetch.
     */
    orderBy?: SpamFeedbackOrderByWithRelationInput | SpamFeedbackOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SpamFeedbacks.
     */
    cursor?: SpamFeedbackWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamFeedbacks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamFeedbacks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SpamFeedbacks.
     */
    distinct?: SpamFeedbackScalarFieldEnum | SpamFeedbackScalarFieldEnum[]
  }

  /**
   * SpamFeedback findFirstOrThrow
   */
  export type SpamFeedbackFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * Filter, which SpamFeedback to fetch.
     */
    where?: SpamFeedbackWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamFeedbacks to fetch.
     */
    orderBy?: SpamFeedbackOrderByWithRelationInput | SpamFeedbackOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SpamFeedbacks.
     */
    cursor?: SpamFeedbackWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamFeedbacks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamFeedbacks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SpamFeedbacks.
     */
    distinct?: SpamFeedbackScalarFieldEnum | SpamFeedbackScalarFieldEnum[]
  }

  /**
   * SpamFeedback findMany
   */
  export type SpamFeedbackFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * Filter, which SpamFeedbacks to fetch.
     */
    where?: SpamFeedbackWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamFeedbacks to fetch.
     */
    orderBy?: SpamFeedbackOrderByWithRelationInput | SpamFeedbackOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SpamFeedbacks.
     */
    cursor?: SpamFeedbackWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamFeedbacks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamFeedbacks.
     */
    skip?: number
    distinct?: SpamFeedbackScalarFieldEnum | SpamFeedbackScalarFieldEnum[]
  }

  /**
   * SpamFeedback create
   */
  export type SpamFeedbackCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * The data needed to create a SpamFeedback.
     */
    data: XOR<SpamFeedbackCreateInput, SpamFeedbackUncheckedCreateInput>
  }

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

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

  /**
   * SpamFeedback update
   */
  export type SpamFeedbackUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * The data needed to update a SpamFeedback.
     */
    data: XOR<SpamFeedbackUpdateInput, SpamFeedbackUncheckedUpdateInput>
    /**
     * Choose, which SpamFeedback to update.
     */
    where: SpamFeedbackWhereUniqueInput
  }

  /**
   * SpamFeedback updateMany
   */
  export type SpamFeedbackUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SpamFeedbacks.
     */
    data: XOR<SpamFeedbackUpdateManyMutationInput, SpamFeedbackUncheckedUpdateManyInput>
    /**
     * Filter which SpamFeedbacks to update
     */
    where?: SpamFeedbackWhereInput
  }

  /**
   * SpamFeedback upsert
   */
  export type SpamFeedbackUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * The filter to search for the SpamFeedback to update in case it exists.
     */
    where: SpamFeedbackWhereUniqueInput
    /**
     * In case the SpamFeedback found by the `where` argument doesn't exist, create a new SpamFeedback with this data.
     */
    create: XOR<SpamFeedbackCreateInput, SpamFeedbackUncheckedCreateInput>
    /**
     * In case the SpamFeedback was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SpamFeedbackUpdateInput, SpamFeedbackUncheckedUpdateInput>
  }

  /**
   * SpamFeedback delete
   */
  export type SpamFeedbackDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamFeedback
     */
    select?: SpamFeedbackSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamFeedbackInclude<ExtArgs> | null
    /**
     * Filter which SpamFeedback to delete.
     */
    where: SpamFeedbackWhereUniqueInput
  }

  /**
   * SpamFeedback deleteMany
   */
  export type SpamFeedbackDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SpamFeedbacks to delete
     */
    where?: SpamFeedbackWhereInput
  }

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


  /**
   * Model SpamRule
   */

  export type AggregateSpamRule = {
    _count: SpamRuleCountAggregateOutputType | null
    _avg: SpamRuleAvgAggregateOutputType | null
    _sum: SpamRuleSumAggregateOutputType | null
    _min: SpamRuleMinAggregateOutputType | null
    _max: SpamRuleMaxAggregateOutputType | null
  }

  export type SpamRuleAvgAggregateOutputType = {
    priority: number | null
  }

  export type SpamRuleSumAggregateOutputType = {
    priority: number | null
  }

  export type SpamRuleMinAggregateOutputType = {
    id: string | null
    userId: string | null
    isGlobal: boolean | null
    ruleType: $Enums.RuleType | null
    pattern: string | null
    action: $Enums.RuleAction | null
    priority: number | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SpamRuleMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    isGlobal: boolean | null
    ruleType: $Enums.RuleType | null
    pattern: string | null
    action: $Enums.RuleAction | null
    priority: number | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SpamRuleCountAggregateOutputType = {
    id: number
    userId: number
    isGlobal: number
    ruleType: number
    pattern: number
    action: number
    priority: number
    isActive: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SpamRuleAvgAggregateInputType = {
    priority?: true
  }

  export type SpamRuleSumAggregateInputType = {
    priority?: true
  }

  export type SpamRuleMinAggregateInputType = {
    id?: true
    userId?: true
    isGlobal?: true
    ruleType?: true
    pattern?: true
    action?: true
    priority?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SpamRuleMaxAggregateInputType = {
    id?: true
    userId?: true
    isGlobal?: true
    ruleType?: true
    pattern?: true
    action?: true
    priority?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SpamRuleCountAggregateInputType = {
    id?: true
    userId?: true
    isGlobal?: true
    ruleType?: true
    pattern?: true
    action?: true
    priority?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SpamRuleAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SpamRule to aggregate.
     */
    where?: SpamRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamRules to fetch.
     */
    orderBy?: SpamRuleOrderByWithRelationInput | SpamRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SpamRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamRules from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SpamRules
    **/
    _count?: true | SpamRuleCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SpamRuleAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SpamRuleSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SpamRuleMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SpamRuleMaxAggregateInputType
  }

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




  export type SpamRuleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SpamRuleWhereInput
    orderBy?: SpamRuleOrderByWithAggregationInput | SpamRuleOrderByWithAggregationInput[]
    by: SpamRuleScalarFieldEnum[] | SpamRuleScalarFieldEnum
    having?: SpamRuleScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SpamRuleCountAggregateInputType | true
    _avg?: SpamRuleAvgAggregateInputType
    _sum?: SpamRuleSumAggregateInputType
    _min?: SpamRuleMinAggregateInputType
    _max?: SpamRuleMaxAggregateInputType
  }

  export type SpamRuleGroupByOutputType = {
    id: string
    userId: string | null
    isGlobal: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority: number
    isActive: boolean
    createdAt: Date
    updatedAt: Date
    _count: SpamRuleCountAggregateOutputType | null
    _avg: SpamRuleAvgAggregateOutputType | null
    _sum: SpamRuleSumAggregateOutputType | null
    _min: SpamRuleMinAggregateOutputType | null
    _max: SpamRuleMaxAggregateOutputType | null
  }

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


  export type SpamRuleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    isGlobal?: boolean
    ruleType?: boolean
    pattern?: boolean
    action?: boolean
    priority?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | SpamRule$userArgs<ExtArgs>
  }, ExtArgs["result"]["spamRule"]>

  export type SpamRuleSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    isGlobal?: boolean
    ruleType?: boolean
    pattern?: boolean
    action?: boolean
    priority?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | SpamRule$userArgs<ExtArgs>
  }, ExtArgs["result"]["spamRule"]>

  export type SpamRuleSelectScalar = {
    id?: boolean
    userId?: boolean
    isGlobal?: boolean
    ruleType?: boolean
    pattern?: boolean
    action?: boolean
    priority?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type SpamRuleInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | SpamRule$userArgs<ExtArgs>
  }
  export type SpamRuleIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | SpamRule$userArgs<ExtArgs>
  }

  export type $SpamRulePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SpamRule"
    objects: {
      user: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string | null
      isGlobal: boolean
      ruleType: $Enums.RuleType
      pattern: string
      action: $Enums.RuleAction
      priority: number
      isActive: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["spamRule"]>
    composites: {}
  }

  type SpamRuleGetPayload<S extends boolean | null | undefined | SpamRuleDefaultArgs> = $Result.GetResult<Prisma.$SpamRulePayload, S>

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

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

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

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

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

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

    /**
     * Create a SpamRule.
     * @param {SpamRuleCreateArgs} args - Arguments to create a SpamRule.
     * @example
     * // Create one SpamRule
     * const SpamRule = await prisma.spamRule.create({
     *   data: {
     *     // ... data to create a SpamRule
     *   }
     * })
     * 
     */
    create<T extends SpamRuleCreateArgs>(args: SelectSubset<T, SpamRuleCreateArgs<ExtArgs>>): Prisma__SpamRuleClient<$Result.GetResult<Prisma.$SpamRulePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a SpamRule.
     * @param {SpamRuleDeleteArgs} args - Arguments to delete one SpamRule.
     * @example
     * // Delete one SpamRule
     * const SpamRule = await prisma.spamRule.delete({
     *   where: {
     *     // ... filter to delete one SpamRule
     *   }
     * })
     * 
     */
    delete<T extends SpamRuleDeleteArgs>(args: SelectSubset<T, SpamRuleDeleteArgs<ExtArgs>>): Prisma__SpamRuleClient<$Result.GetResult<Prisma.$SpamRulePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the SpamRule model
   */ 
  interface SpamRuleFieldRefs {
    readonly id: FieldRef<"SpamRule", 'String'>
    readonly userId: FieldRef<"SpamRule", 'String'>
    readonly isGlobal: FieldRef<"SpamRule", 'Boolean'>
    readonly ruleType: FieldRef<"SpamRule", 'RuleType'>
    readonly pattern: FieldRef<"SpamRule", 'String'>
    readonly action: FieldRef<"SpamRule", 'RuleAction'>
    readonly priority: FieldRef<"SpamRule", 'Int'>
    readonly isActive: FieldRef<"SpamRule", 'Boolean'>
    readonly createdAt: FieldRef<"SpamRule", 'DateTime'>
    readonly updatedAt: FieldRef<"SpamRule", 'DateTime'>
  }
    

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

  /**
   * SpamRule findUniqueOrThrow
   */
  export type SpamRuleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * Filter, which SpamRule to fetch.
     */
    where: SpamRuleWhereUniqueInput
  }

  /**
   * SpamRule findFirst
   */
  export type SpamRuleFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * Filter, which SpamRule to fetch.
     */
    where?: SpamRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamRules to fetch.
     */
    orderBy?: SpamRuleOrderByWithRelationInput | SpamRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SpamRules.
     */
    cursor?: SpamRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamRules from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SpamRules.
     */
    distinct?: SpamRuleScalarFieldEnum | SpamRuleScalarFieldEnum[]
  }

  /**
   * SpamRule findFirstOrThrow
   */
  export type SpamRuleFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * Filter, which SpamRule to fetch.
     */
    where?: SpamRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamRules to fetch.
     */
    orderBy?: SpamRuleOrderByWithRelationInput | SpamRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SpamRules.
     */
    cursor?: SpamRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamRules from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SpamRules.
     */
    distinct?: SpamRuleScalarFieldEnum | SpamRuleScalarFieldEnum[]
  }

  /**
   * SpamRule findMany
   */
  export type SpamRuleFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * Filter, which SpamRules to fetch.
     */
    where?: SpamRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SpamRules to fetch.
     */
    orderBy?: SpamRuleOrderByWithRelationInput | SpamRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SpamRules.
     */
    cursor?: SpamRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SpamRules from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SpamRules.
     */
    skip?: number
    distinct?: SpamRuleScalarFieldEnum | SpamRuleScalarFieldEnum[]
  }

  /**
   * SpamRule create
   */
  export type SpamRuleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * The data needed to create a SpamRule.
     */
    data: XOR<SpamRuleCreateInput, SpamRuleUncheckedCreateInput>
  }

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

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

  /**
   * SpamRule update
   */
  export type SpamRuleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * The data needed to update a SpamRule.
     */
    data: XOR<SpamRuleUpdateInput, SpamRuleUncheckedUpdateInput>
    /**
     * Choose, which SpamRule to update.
     */
    where: SpamRuleWhereUniqueInput
  }

  /**
   * SpamRule updateMany
   */
  export type SpamRuleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SpamRules.
     */
    data: XOR<SpamRuleUpdateManyMutationInput, SpamRuleUncheckedUpdateManyInput>
    /**
     * Filter which SpamRules to update
     */
    where?: SpamRuleWhereInput
  }

  /**
   * SpamRule upsert
   */
  export type SpamRuleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * The filter to search for the SpamRule to update in case it exists.
     */
    where: SpamRuleWhereUniqueInput
    /**
     * In case the SpamRule found by the `where` argument doesn't exist, create a new SpamRule with this data.
     */
    create: XOR<SpamRuleCreateInput, SpamRuleUncheckedCreateInput>
    /**
     * In case the SpamRule was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SpamRuleUpdateInput, SpamRuleUncheckedUpdateInput>
  }

  /**
   * SpamRule delete
   */
  export type SpamRuleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SpamRule
     */
    select?: SpamRuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SpamRuleInclude<ExtArgs> | null
    /**
     * Filter which SpamRule to delete.
     */
    where: SpamRuleWhereUniqueInput
  }

  /**
   * SpamRule deleteMany
   */
  export type SpamRuleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SpamRules to delete
     */
    where?: SpamRuleWhereInput
  }

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

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


  /**
   * Model AuditLog
   */

  export type AggregateAuditLog = {
    _count: AuditLogCountAggregateOutputType | null
    _min: AuditLogMinAggregateOutputType | null
    _max: AuditLogMaxAggregateOutputType | null
  }

  export type AuditLogMinAggregateOutputType = {
    id: string | null
    userId: string | null
    action: string | null
    resource: string | null
    resourceId: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
  }

  export type AuditLogMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    action: string | null
    resource: string | null
    resourceId: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
  }

  export type AuditLogCountAggregateOutputType = {
    id: number
    userId: number
    action: number
    resource: number
    resourceId: number
    changes: number
    metadata: number
    ipAddress: number
    userAgent: number
    createdAt: number
    _all: number
  }


  export type AuditLogMinAggregateInputType = {
    id?: true
    userId?: true
    action?: true
    resource?: true
    resourceId?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
  }

  export type AuditLogMaxAggregateInputType = {
    id?: true
    userId?: true
    action?: true
    resource?: true
    resourceId?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
  }

  export type AuditLogCountAggregateInputType = {
    id?: true
    userId?: true
    action?: true
    resource?: true
    resourceId?: true
    changes?: true
    metadata?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    _all?: true
  }

  export type AuditLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AuditLog to aggregate.
     */
    where?: AuditLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuditLogs to fetch.
     */
    orderBy?: AuditLogOrderByWithRelationInput | AuditLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AuditLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuditLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AuditLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AuditLogs
    **/
    _count?: true | AuditLogCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AuditLogMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AuditLogMaxAggregateInputType
  }

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




  export type AuditLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AuditLogWhereInput
    orderBy?: AuditLogOrderByWithAggregationInput | AuditLogOrderByWithAggregationInput[]
    by: AuditLogScalarFieldEnum[] | AuditLogScalarFieldEnum
    having?: AuditLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AuditLogCountAggregateInputType | true
    _min?: AuditLogMinAggregateInputType
    _max?: AuditLogMaxAggregateInputType
  }

  export type AuditLogGroupByOutputType = {
    id: string
    userId: string | null
    action: string
    resource: string
    resourceId: string | null
    changes: JsonValue | null
    metadata: JsonValue | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date
    _count: AuditLogCountAggregateOutputType | null
    _min: AuditLogMinAggregateOutputType | null
    _max: AuditLogMaxAggregateOutputType | null
  }

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


  export type AuditLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    action?: boolean
    resource?: boolean
    resourceId?: boolean
    changes?: boolean
    metadata?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["auditLog"]>

  export type AuditLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    action?: boolean
    resource?: boolean
    resourceId?: boolean
    changes?: boolean
    metadata?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["auditLog"]>

  export type AuditLogSelectScalar = {
    id?: boolean
    userId?: boolean
    action?: boolean
    resource?: boolean
    resourceId?: boolean
    changes?: boolean
    metadata?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
  }


  export type $AuditLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AuditLog"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string | null
      action: string
      resource: string
      resourceId: string | null
      changes: Prisma.JsonValue | null
      metadata: Prisma.JsonValue | null
      ipAddress: string | null
      userAgent: string | null
      createdAt: Date
    }, ExtArgs["result"]["auditLog"]>
    composites: {}
  }

  type AuditLogGetPayload<S extends boolean | null | undefined | AuditLogDefaultArgs> = $Result.GetResult<Prisma.$AuditLogPayload, S>

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

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

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

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

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

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

    /**
     * Create a AuditLog.
     * @param {AuditLogCreateArgs} args - Arguments to create a AuditLog.
     * @example
     * // Create one AuditLog
     * const AuditLog = await prisma.auditLog.create({
     *   data: {
     *     // ... data to create a AuditLog
     *   }
     * })
     * 
     */
    create<T extends AuditLogCreateArgs>(args: SelectSubset<T, AuditLogCreateArgs<ExtArgs>>): Prisma__AuditLogClient<$Result.GetResult<Prisma.$AuditLogPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a AuditLog.
     * @param {AuditLogDeleteArgs} args - Arguments to delete one AuditLog.
     * @example
     * // Delete one AuditLog
     * const AuditLog = await prisma.auditLog.delete({
     *   where: {
     *     // ... filter to delete one AuditLog
     *   }
     * })
     * 
     */
    delete<T extends AuditLogDeleteArgs>(args: SelectSubset<T, AuditLogDeleteArgs<ExtArgs>>): Prisma__AuditLogClient<$Result.GetResult<Prisma.$AuditLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the AuditLog model
   */ 
  interface AuditLogFieldRefs {
    readonly id: FieldRef<"AuditLog", 'String'>
    readonly userId: FieldRef<"AuditLog", 'String'>
    readonly action: FieldRef<"AuditLog", 'String'>
    readonly resource: FieldRef<"AuditLog", 'String'>
    readonly resourceId: FieldRef<"AuditLog", 'String'>
    readonly changes: FieldRef<"AuditLog", 'Json'>
    readonly metadata: FieldRef<"AuditLog", 'Json'>
    readonly ipAddress: FieldRef<"AuditLog", 'String'>
    readonly userAgent: FieldRef<"AuditLog", 'String'>
    readonly createdAt: FieldRef<"AuditLog", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * AuditLog findUnique
   */
  export type AuditLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter, which AuditLog to fetch.
     */
    where: AuditLogWhereUniqueInput
  }

  /**
   * AuditLog findUniqueOrThrow
   */
  export type AuditLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter, which AuditLog to fetch.
     */
    where: AuditLogWhereUniqueInput
  }

  /**
   * AuditLog findFirst
   */
  export type AuditLogFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter, which AuditLog to fetch.
     */
    where?: AuditLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuditLogs to fetch.
     */
    orderBy?: AuditLogOrderByWithRelationInput | AuditLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AuditLogs.
     */
    cursor?: AuditLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuditLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AuditLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AuditLogs.
     */
    distinct?: AuditLogScalarFieldEnum | AuditLogScalarFieldEnum[]
  }

  /**
   * AuditLog findFirstOrThrow
   */
  export type AuditLogFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter, which AuditLog to fetch.
     */
    where?: AuditLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuditLogs to fetch.
     */
    orderBy?: AuditLogOrderByWithRelationInput | AuditLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AuditLogs.
     */
    cursor?: AuditLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuditLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AuditLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AuditLogs.
     */
    distinct?: AuditLogScalarFieldEnum | AuditLogScalarFieldEnum[]
  }

  /**
   * AuditLog findMany
   */
  export type AuditLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter, which AuditLogs to fetch.
     */
    where?: AuditLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuditLogs to fetch.
     */
    orderBy?: AuditLogOrderByWithRelationInput | AuditLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AuditLogs.
     */
    cursor?: AuditLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuditLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AuditLogs.
     */
    skip?: number
    distinct?: AuditLogScalarFieldEnum | AuditLogScalarFieldEnum[]
  }

  /**
   * AuditLog create
   */
  export type AuditLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * The data needed to create a AuditLog.
     */
    data: XOR<AuditLogCreateInput, AuditLogUncheckedCreateInput>
  }

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

  /**
   * AuditLog createManyAndReturn
   */
  export type AuditLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many AuditLogs.
     */
    data: AuditLogCreateManyInput | AuditLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * AuditLog update
   */
  export type AuditLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * The data needed to update a AuditLog.
     */
    data: XOR<AuditLogUpdateInput, AuditLogUncheckedUpdateInput>
    /**
     * Choose, which AuditLog to update.
     */
    where: AuditLogWhereUniqueInput
  }

  /**
   * AuditLog updateMany
   */
  export type AuditLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AuditLogs.
     */
    data: XOR<AuditLogUpdateManyMutationInput, AuditLogUncheckedUpdateManyInput>
    /**
     * Filter which AuditLogs to update
     */
    where?: AuditLogWhereInput
  }

  /**
   * AuditLog upsert
   */
  export type AuditLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * The filter to search for the AuditLog to update in case it exists.
     */
    where: AuditLogWhereUniqueInput
    /**
     * In case the AuditLog found by the `where` argument doesn't exist, create a new AuditLog with this data.
     */
    create: XOR<AuditLogCreateInput, AuditLogUncheckedCreateInput>
    /**
     * In case the AuditLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AuditLogUpdateInput, AuditLogUncheckedUpdateInput>
  }

  /**
   * AuditLog delete
   */
  export type AuditLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
    /**
     * Filter which AuditLog to delete.
     */
    where: AuditLogWhereUniqueInput
  }

  /**
   * AuditLog deleteMany
   */
  export type AuditLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AuditLogs to delete
     */
    where?: AuditLogWhereInput
  }

  /**
   * AuditLog without action
   */
  export type AuditLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuditLog
     */
    select?: AuditLogSelect<ExtArgs> | null
  }


  /**
   * Model KPISnapshot
   */

  export type AggregateKPISnapshot = {
    _count: KPISnapshotCountAggregateOutputType | null
    _avg: KPISnapshotAvgAggregateOutputType | null
    _sum: KPISnapshotSumAggregateOutputType | null
    _min: KPISnapshotMinAggregateOutputType | null
    _max: KPISnapshotMaxAggregateOutputType | null
  }

  export type KPISnapshotAvgAggregateOutputType = {
    metricValue: number | null
  }

  export type KPISnapshotSumAggregateOutputType = {
    metricValue: number | null
  }

  export type KPISnapshotMinAggregateOutputType = {
    id: string | null
    date: Date | null
    metricName: string | null
    metricValue: number | null
    createdAt: Date | null
  }

  export type KPISnapshotMaxAggregateOutputType = {
    id: string | null
    date: Date | null
    metricName: string | null
    metricValue: number | null
    createdAt: Date | null
  }

  export type KPISnapshotCountAggregateOutputType = {
    id: number
    date: number
    metricName: number
    metricValue: number
    metadata: number
    createdAt: number
    _all: number
  }


  export type KPISnapshotAvgAggregateInputType = {
    metricValue?: true
  }

  export type KPISnapshotSumAggregateInputType = {
    metricValue?: true
  }

  export type KPISnapshotMinAggregateInputType = {
    id?: true
    date?: true
    metricName?: true
    metricValue?: true
    createdAt?: true
  }

  export type KPISnapshotMaxAggregateInputType = {
    id?: true
    date?: true
    metricName?: true
    metricValue?: true
    createdAt?: true
  }

  export type KPISnapshotCountAggregateInputType = {
    id?: true
    date?: true
    metricName?: true
    metricValue?: true
    metadata?: true
    createdAt?: true
    _all?: true
  }

  export type KPISnapshotAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which KPISnapshot to aggregate.
     */
    where?: KPISnapshotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KPISnapshots to fetch.
     */
    orderBy?: KPISnapshotOrderByWithRelationInput | KPISnapshotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: KPISnapshotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KPISnapshots from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` KPISnapshots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned KPISnapshots
    **/
    _count?: true | KPISnapshotCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: KPISnapshotAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: KPISnapshotSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: KPISnapshotMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: KPISnapshotMaxAggregateInputType
  }

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




  export type KPISnapshotGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: KPISnapshotWhereInput
    orderBy?: KPISnapshotOrderByWithAggregationInput | KPISnapshotOrderByWithAggregationInput[]
    by: KPISnapshotScalarFieldEnum[] | KPISnapshotScalarFieldEnum
    having?: KPISnapshotScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: KPISnapshotCountAggregateInputType | true
    _avg?: KPISnapshotAvgAggregateInputType
    _sum?: KPISnapshotSumAggregateInputType
    _min?: KPISnapshotMinAggregateInputType
    _max?: KPISnapshotMaxAggregateInputType
  }

  export type KPISnapshotGroupByOutputType = {
    id: string
    date: Date
    metricName: string
    metricValue: number
    metadata: JsonValue | null
    createdAt: Date
    _count: KPISnapshotCountAggregateOutputType | null
    _avg: KPISnapshotAvgAggregateOutputType | null
    _sum: KPISnapshotSumAggregateOutputType | null
    _min: KPISnapshotMinAggregateOutputType | null
    _max: KPISnapshotMaxAggregateOutputType | null
  }

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


  export type KPISnapshotSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    metricName?: boolean
    metricValue?: boolean
    metadata?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["kPISnapshot"]>

  export type KPISnapshotSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    metricName?: boolean
    metricValue?: boolean
    metadata?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["kPISnapshot"]>

  export type KPISnapshotSelectScalar = {
    id?: boolean
    date?: boolean
    metricName?: boolean
    metricValue?: boolean
    metadata?: boolean
    createdAt?: boolean
  }


  export type $KPISnapshotPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "KPISnapshot"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      date: Date
      metricName: string
      metricValue: number
      metadata: Prisma.JsonValue | null
      createdAt: Date
    }, ExtArgs["result"]["kPISnapshot"]>
    composites: {}
  }

  type KPISnapshotGetPayload<S extends boolean | null | undefined | KPISnapshotDefaultArgs> = $Result.GetResult<Prisma.$KPISnapshotPayload, S>

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

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

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

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

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

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

    /**
     * Create a KPISnapshot.
     * @param {KPISnapshotCreateArgs} args - Arguments to create a KPISnapshot.
     * @example
     * // Create one KPISnapshot
     * const KPISnapshot = await prisma.kPISnapshot.create({
     *   data: {
     *     // ... data to create a KPISnapshot
     *   }
     * })
     * 
     */
    create<T extends KPISnapshotCreateArgs>(args: SelectSubset<T, KPISnapshotCreateArgs<ExtArgs>>): Prisma__KPISnapshotClient<$Result.GetResult<Prisma.$KPISnapshotPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a KPISnapshot.
     * @param {KPISnapshotDeleteArgs} args - Arguments to delete one KPISnapshot.
     * @example
     * // Delete one KPISnapshot
     * const KPISnapshot = await prisma.kPISnapshot.delete({
     *   where: {
     *     // ... filter to delete one KPISnapshot
     *   }
     * })
     * 
     */
    delete<T extends KPISnapshotDeleteArgs>(args: SelectSubset<T, KPISnapshotDeleteArgs<ExtArgs>>): Prisma__KPISnapshotClient<$Result.GetResult<Prisma.$KPISnapshotPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the KPISnapshot model
   */ 
  interface KPISnapshotFieldRefs {
    readonly id: FieldRef<"KPISnapshot", 'String'>
    readonly date: FieldRef<"KPISnapshot", 'DateTime'>
    readonly metricName: FieldRef<"KPISnapshot", 'String'>
    readonly metricValue: FieldRef<"KPISnapshot", 'Float'>
    readonly metadata: FieldRef<"KPISnapshot", 'Json'>
    readonly createdAt: FieldRef<"KPISnapshot", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * KPISnapshot findUnique
   */
  export type KPISnapshotFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter, which KPISnapshot to fetch.
     */
    where: KPISnapshotWhereUniqueInput
  }

  /**
   * KPISnapshot findUniqueOrThrow
   */
  export type KPISnapshotFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter, which KPISnapshot to fetch.
     */
    where: KPISnapshotWhereUniqueInput
  }

  /**
   * KPISnapshot findFirst
   */
  export type KPISnapshotFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter, which KPISnapshot to fetch.
     */
    where?: KPISnapshotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KPISnapshots to fetch.
     */
    orderBy?: KPISnapshotOrderByWithRelationInput | KPISnapshotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for KPISnapshots.
     */
    cursor?: KPISnapshotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KPISnapshots from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` KPISnapshots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of KPISnapshots.
     */
    distinct?: KPISnapshotScalarFieldEnum | KPISnapshotScalarFieldEnum[]
  }

  /**
   * KPISnapshot findFirstOrThrow
   */
  export type KPISnapshotFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter, which KPISnapshot to fetch.
     */
    where?: KPISnapshotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KPISnapshots to fetch.
     */
    orderBy?: KPISnapshotOrderByWithRelationInput | KPISnapshotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for KPISnapshots.
     */
    cursor?: KPISnapshotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KPISnapshots from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` KPISnapshots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of KPISnapshots.
     */
    distinct?: KPISnapshotScalarFieldEnum | KPISnapshotScalarFieldEnum[]
  }

  /**
   * KPISnapshot findMany
   */
  export type KPISnapshotFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter, which KPISnapshots to fetch.
     */
    where?: KPISnapshotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KPISnapshots to fetch.
     */
    orderBy?: KPISnapshotOrderByWithRelationInput | KPISnapshotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing KPISnapshots.
     */
    cursor?: KPISnapshotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KPISnapshots from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` KPISnapshots.
     */
    skip?: number
    distinct?: KPISnapshotScalarFieldEnum | KPISnapshotScalarFieldEnum[]
  }

  /**
   * KPISnapshot create
   */
  export type KPISnapshotCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * The data needed to create a KPISnapshot.
     */
    data: XOR<KPISnapshotCreateInput, KPISnapshotUncheckedCreateInput>
  }

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

  /**
   * KPISnapshot createManyAndReturn
   */
  export type KPISnapshotCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many KPISnapshots.
     */
    data: KPISnapshotCreateManyInput | KPISnapshotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * KPISnapshot update
   */
  export type KPISnapshotUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * The data needed to update a KPISnapshot.
     */
    data: XOR<KPISnapshotUpdateInput, KPISnapshotUncheckedUpdateInput>
    /**
     * Choose, which KPISnapshot to update.
     */
    where: KPISnapshotWhereUniqueInput
  }

  /**
   * KPISnapshot updateMany
   */
  export type KPISnapshotUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update KPISnapshots.
     */
    data: XOR<KPISnapshotUpdateManyMutationInput, KPISnapshotUncheckedUpdateManyInput>
    /**
     * Filter which KPISnapshots to update
     */
    where?: KPISnapshotWhereInput
  }

  /**
   * KPISnapshot upsert
   */
  export type KPISnapshotUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * The filter to search for the KPISnapshot to update in case it exists.
     */
    where: KPISnapshotWhereUniqueInput
    /**
     * In case the KPISnapshot found by the `where` argument doesn't exist, create a new KPISnapshot with this data.
     */
    create: XOR<KPISnapshotCreateInput, KPISnapshotUncheckedCreateInput>
    /**
     * In case the KPISnapshot was found with the provided `where` argument, update it with this data.
     */
    update: XOR<KPISnapshotUpdateInput, KPISnapshotUncheckedUpdateInput>
  }

  /**
   * KPISnapshot delete
   */
  export type KPISnapshotDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<ExtArgs> | null
    /**
     * Filter which KPISnapshot to delete.
     */
    where: KPISnapshotWhereUniqueInput
  }

  /**
   * KPISnapshot deleteMany
   */
  export type KPISnapshotDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which KPISnapshots to delete
     */
    where?: KPISnapshotWhereInput
  }

  /**
   * KPISnapshot without action
   */
  export type KPISnapshotDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KPISnapshot
     */
    select?: KPISnapshotSelect<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',
    email: 'email',
    emailVerified: 'emailVerified',
    name: 'name',
    image: 'image',
    role: 'role',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const AccountScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    provider: 'provider',
    providerAccountId: 'providerAccountId',
    access_token: 'access_token',
    refresh_token: 'refresh_token',
    expires_at: 'expires_at',
    token_type: 'token_type',
    scope: 'scope',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SessionScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    sessionToken: 'sessionToken',
    expires: 'expires',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const FamilyGroupScalarFieldEnum: {
    id: 'id',
    name: 'name',
    ownerId: 'ownerId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const FamilyGroupMemberScalarFieldEnum: {
    id: 'id',
    groupId: 'groupId',
    userId: 'userId',
    role: 'role',
    joinedAt: 'joinedAt',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SubscriptionScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    familyGroupId: 'familyGroupId',
    stripeId: 'stripeId',
    tier: 'tier',
    status: 'status',
    currentPeriodStart: 'currentPeriodStart',
    currentPeriodEnd: 'currentPeriodEnd',
    cancelAtPeriodEnd: 'cancelAtPeriodEnd',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const WatchlistItemScalarFieldEnum: {
    id: 'id',
    subscriptionId: 'subscriptionId',
    type: 'type',
    value: 'value',
    hash: 'hash',
    isActive: 'isActive',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const ExposureScalarFieldEnum: {
    id: 'id',
    subscriptionId: 'subscriptionId',
    watchlistItemId: 'watchlistItemId',
    source: 'source',
    dataType: 'dataType',
    identifier: 'identifier',
    identifierHash: 'identifierHash',
    severity: 'severity',
    metadata: 'metadata',
    isFirstTime: 'isFirstTime',
    detectedAt: 'detectedAt',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const AlertScalarFieldEnum: {
    id: 'id',
    subscriptionId: 'subscriptionId',
    userId: 'userId',
    exposureId: 'exposureId',
    type: 'type',
    title: 'title',
    message: 'message',
    severity: 'severity',
    isRead: 'isRead',
    readAt: 'readAt',
    channel: 'channel',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const VoiceEnrollmentScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    name: 'name',
    voiceHash: 'voiceHash',
    audioMetadata: 'audioMetadata',
    isActive: 'isActive',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const VoiceAnalysisScalarFieldEnum: {
    id: 'id',
    enrollmentId: 'enrollmentId',
    userId: 'userId',
    audioHash: 'audioHash',
    isSynthetic: 'isSynthetic',
    confidence: 'confidence',
    analysisResult: 'analysisResult',
    audioUrl: 'audioUrl',
    createdAt: 'createdAt'
  };

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


  export const SpamFeedbackScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    phoneNumber: 'phoneNumber',
    phoneNumberHash: 'phoneNumberHash',
    isSpam: 'isSpam',
    confidence: 'confidence',
    feedbackType: 'feedbackType',
    metadata: 'metadata',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SpamRuleScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    isGlobal: 'isGlobal',
    ruleType: 'ruleType',
    pattern: 'pattern',
    action: 'action',
    priority: 'priority',
    isActive: 'isActive',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const AuditLogScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    action: 'action',
    resource: 'resource',
    resourceId: 'resourceId',
    changes: 'changes',
    metadata: 'metadata',
    ipAddress: 'ipAddress',
    userAgent: 'userAgent',
    createdAt: 'createdAt'
  };

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


  export const KPISnapshotScalarFieldEnum: {
    id: 'id',
    date: 'date',
    metricName: 'metricName',
    metricValue: 'metricValue',
    metadata: 'metadata',
    createdAt: 'createdAt'
  };

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


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

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


  export const NullableJsonNullValueInput: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull
  };

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


  export const JsonNullValueInput: {
    JsonNull: typeof JsonNull
  };

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


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

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


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

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


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

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


  /**
   * Field references 
   */


  /**
   * Reference to a field of type '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 'UserRole'
   */
  export type EnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole'>
    


  /**
   * Reference to a field of type 'UserRole[]'
   */
  export type ListEnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole[]'>
    


  /**
   * 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 'FamilyMemberRole'
   */
  export type EnumFamilyMemberRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FamilyMemberRole'>
    


  /**
   * Reference to a field of type 'FamilyMemberRole[]'
   */
  export type ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FamilyMemberRole[]'>
    


  /**
   * Reference to a field of type 'SubscriptionTier'
   */
  export type EnumSubscriptionTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionTier'>
    


  /**
   * Reference to a field of type 'SubscriptionTier[]'
   */
  export type ListEnumSubscriptionTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionTier[]'>
    


  /**
   * Reference to a field of type 'SubscriptionStatus'
   */
  export type EnumSubscriptionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionStatus'>
    


  /**
   * Reference to a field of type 'SubscriptionStatus[]'
   */
  export type ListEnumSubscriptionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionStatus[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'WatchlistType'
   */
  export type EnumWatchlistTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatchlistType'>
    


  /**
   * Reference to a field of type 'WatchlistType[]'
   */
  export type ListEnumWatchlistTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatchlistType[]'>
    


  /**
   * Reference to a field of type 'ExposureSource'
   */
  export type EnumExposureSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExposureSource'>
    


  /**
   * Reference to a field of type 'ExposureSource[]'
   */
  export type ListEnumExposureSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExposureSource[]'>
    


  /**
   * Reference to a field of type 'ExposureSeverity'
   */
  export type EnumExposureSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExposureSeverity'>
    


  /**
   * Reference to a field of type 'ExposureSeverity[]'
   */
  export type ListEnumExposureSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExposureSeverity[]'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'AlertType'
   */
  export type EnumAlertTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertType'>
    


  /**
   * Reference to a field of type 'AlertType[]'
   */
  export type ListEnumAlertTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertType[]'>
    


  /**
   * Reference to a field of type 'AlertSeverity'
   */
  export type EnumAlertSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertSeverity'>
    


  /**
   * Reference to a field of type 'AlertSeverity[]'
   */
  export type ListEnumAlertSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertSeverity[]'>
    


  /**
   * Reference to a field of type 'AlertChannel[]'
   */
  export type ListEnumAlertChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertChannel[]'>
    


  /**
   * Reference to a field of type 'AlertChannel'
   */
  export type EnumAlertChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AlertChannel'>
    


  /**
   * 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[]'>
    


  /**
   * Reference to a field of type 'FeedbackType'
   */
  export type EnumFeedbackTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FeedbackType'>
    


  /**
   * Reference to a field of type 'FeedbackType[]'
   */
  export type ListEnumFeedbackTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FeedbackType[]'>
    


  /**
   * Reference to a field of type 'RuleType'
   */
  export type EnumRuleTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleType'>
    


  /**
   * Reference to a field of type 'RuleType[]'
   */
  export type ListEnumRuleTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleType[]'>
    


  /**
   * Reference to a field of type 'RuleAction'
   */
  export type EnumRuleActionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleAction'>
    


  /**
   * Reference to a field of type 'RuleAction[]'
   */
  export type ListEnumRuleActionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleAction[]'>
    
  /**
   * Deep Input Types
   */


  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
    name?: StringNullableFilter<"User"> | string | null
    image?: StringNullableFilter<"User"> | string | null
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accounts?: AccountListRelationFilter
    sessions?: SessionListRelationFilter
    familyGroups?: FamilyGroupMemberListRelationFilter
    familyGroupOwned?: FamilyGroupListRelationFilter
    subscriptions?: SubscriptionListRelationFilter
    alerts?: AlertListRelationFilter
    voiceEnrollments?: VoiceEnrollmentListRelationFilter
    voiceAnalyses?: VoiceAnalysisListRelationFilter
    spamFeedback?: SpamFeedbackListRelationFilter
    spamRules?: SpamRuleListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    accounts?: AccountOrderByRelationAggregateInput
    sessions?: SessionOrderByRelationAggregateInput
    familyGroups?: FamilyGroupMemberOrderByRelationAggregateInput
    familyGroupOwned?: FamilyGroupOrderByRelationAggregateInput
    subscriptions?: SubscriptionOrderByRelationAggregateInput
    alerts?: AlertOrderByRelationAggregateInput
    voiceEnrollments?: VoiceEnrollmentOrderByRelationAggregateInput
    voiceAnalyses?: VoiceAnalysisOrderByRelationAggregateInput
    spamFeedback?: SpamFeedbackOrderByRelationAggregateInput
    spamRules?: SpamRuleOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
    name?: StringNullableFilter<"User"> | string | null
    image?: StringNullableFilter<"User"> | string | null
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accounts?: AccountListRelationFilter
    sessions?: SessionListRelationFilter
    familyGroups?: FamilyGroupMemberListRelationFilter
    familyGroupOwned?: FamilyGroupListRelationFilter
    subscriptions?: SubscriptionListRelationFilter
    alerts?: AlertListRelationFilter
    voiceEnrollments?: VoiceEnrollmentListRelationFilter
    voiceAnalyses?: VoiceAnalysisListRelationFilter
    spamFeedback?: SpamFeedbackListRelationFilter
    spamRules?: SpamRuleListRelationFilter
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    emailVerified?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    name?: StringNullableWithAggregatesFilter<"User"> | string | null
    image?: StringNullableWithAggregatesFilter<"User"> | string | null
    role?: EnumUserRoleWithAggregatesFilter<"User"> | $Enums.UserRole
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type AccountWhereInput = {
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    id?: StringFilter<"Account"> | string
    userId?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    access_token?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type AccountOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    access_token?: SortOrderInput | SortOrder
    refresh_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    scope?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type AccountWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId_provider_providerAccountId?: AccountUserIdProviderProviderAccountIdCompoundUniqueInput
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    userId?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    access_token?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "userId_provider_providerAccountId">

  export type AccountOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    access_token?: SortOrderInput | SortOrder
    refresh_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    scope?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AccountCountOrderByAggregateInput
    _avg?: AccountAvgOrderByAggregateInput
    _max?: AccountMaxOrderByAggregateInput
    _min?: AccountMinOrderByAggregateInput
    _sum?: AccountSumOrderByAggregateInput
  }

  export type AccountScalarWhereWithAggregatesInput = {
    AND?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    OR?: AccountScalarWhereWithAggregatesInput[]
    NOT?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Account"> | string
    userId?: StringWithAggregatesFilter<"Account"> | string
    provider?: StringWithAggregatesFilter<"Account"> | string
    providerAccountId?: StringWithAggregatesFilter<"Account"> | string
    access_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    refresh_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    expires_at?: IntNullableWithAggregatesFilter<"Account"> | number | null
    token_type?: StringNullableWithAggregatesFilter<"Account"> | string | null
    scope?: StringNullableWithAggregatesFilter<"Account"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
  }

  export type SessionWhereInput = {
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    id?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type SessionOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    sessionToken?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    sessionToken?: string
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "sessionToken">

  export type SessionOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    sessionToken?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SessionCountOrderByAggregateInput
    _max?: SessionMaxOrderByAggregateInput
    _min?: SessionMinOrderByAggregateInput
  }

  export type SessionScalarWhereWithAggregatesInput = {
    AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    OR?: SessionScalarWhereWithAggregatesInput[]
    NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Session"> | string
    userId?: StringWithAggregatesFilter<"Session"> | string
    sessionToken?: StringWithAggregatesFilter<"Session"> | string
    expires?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
  }

  export type FamilyGroupWhereInput = {
    AND?: FamilyGroupWhereInput | FamilyGroupWhereInput[]
    OR?: FamilyGroupWhereInput[]
    NOT?: FamilyGroupWhereInput | FamilyGroupWhereInput[]
    id?: StringFilter<"FamilyGroup"> | string
    name?: StringFilter<"FamilyGroup"> | string
    ownerId?: StringFilter<"FamilyGroup"> | string
    createdAt?: DateTimeFilter<"FamilyGroup"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroup"> | Date | string
    owner?: XOR<UserRelationFilter, UserWhereInput>
    members?: FamilyGroupMemberListRelationFilter
    subscriptions?: SubscriptionListRelationFilter
  }

  export type FamilyGroupOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    ownerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    owner?: UserOrderByWithRelationInput
    members?: FamilyGroupMemberOrderByRelationAggregateInput
    subscriptions?: SubscriptionOrderByRelationAggregateInput
  }

  export type FamilyGroupWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FamilyGroupWhereInput | FamilyGroupWhereInput[]
    OR?: FamilyGroupWhereInput[]
    NOT?: FamilyGroupWhereInput | FamilyGroupWhereInput[]
    name?: StringFilter<"FamilyGroup"> | string
    ownerId?: StringFilter<"FamilyGroup"> | string
    createdAt?: DateTimeFilter<"FamilyGroup"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroup"> | Date | string
    owner?: XOR<UserRelationFilter, UserWhereInput>
    members?: FamilyGroupMemberListRelationFilter
    subscriptions?: SubscriptionListRelationFilter
  }, "id">

  export type FamilyGroupOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    ownerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: FamilyGroupCountOrderByAggregateInput
    _max?: FamilyGroupMaxOrderByAggregateInput
    _min?: FamilyGroupMinOrderByAggregateInput
  }

  export type FamilyGroupScalarWhereWithAggregatesInput = {
    AND?: FamilyGroupScalarWhereWithAggregatesInput | FamilyGroupScalarWhereWithAggregatesInput[]
    OR?: FamilyGroupScalarWhereWithAggregatesInput[]
    NOT?: FamilyGroupScalarWhereWithAggregatesInput | FamilyGroupScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"FamilyGroup"> | string
    name?: StringWithAggregatesFilter<"FamilyGroup"> | string
    ownerId?: StringWithAggregatesFilter<"FamilyGroup"> | string
    createdAt?: DateTimeWithAggregatesFilter<"FamilyGroup"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"FamilyGroup"> | Date | string
  }

  export type FamilyGroupMemberWhereInput = {
    AND?: FamilyGroupMemberWhereInput | FamilyGroupMemberWhereInput[]
    OR?: FamilyGroupMemberWhereInput[]
    NOT?: FamilyGroupMemberWhereInput | FamilyGroupMemberWhereInput[]
    id?: StringFilter<"FamilyGroupMember"> | string
    groupId?: StringFilter<"FamilyGroupMember"> | string
    userId?: StringFilter<"FamilyGroupMember"> | string
    role?: EnumFamilyMemberRoleFilter<"FamilyGroupMember"> | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    createdAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    group?: XOR<FamilyGroupRelationFilter, FamilyGroupWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type FamilyGroupMemberOrderByWithRelationInput = {
    id?: SortOrder
    groupId?: SortOrder
    userId?: SortOrder
    role?: SortOrder
    joinedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    group?: FamilyGroupOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type FamilyGroupMemberWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    groupId_userId?: FamilyGroupMemberGroupIdUserIdCompoundUniqueInput
    AND?: FamilyGroupMemberWhereInput | FamilyGroupMemberWhereInput[]
    OR?: FamilyGroupMemberWhereInput[]
    NOT?: FamilyGroupMemberWhereInput | FamilyGroupMemberWhereInput[]
    groupId?: StringFilter<"FamilyGroupMember"> | string
    userId?: StringFilter<"FamilyGroupMember"> | string
    role?: EnumFamilyMemberRoleFilter<"FamilyGroupMember"> | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    createdAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    group?: XOR<FamilyGroupRelationFilter, FamilyGroupWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "groupId_userId">

  export type FamilyGroupMemberOrderByWithAggregationInput = {
    id?: SortOrder
    groupId?: SortOrder
    userId?: SortOrder
    role?: SortOrder
    joinedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: FamilyGroupMemberCountOrderByAggregateInput
    _max?: FamilyGroupMemberMaxOrderByAggregateInput
    _min?: FamilyGroupMemberMinOrderByAggregateInput
  }

  export type FamilyGroupMemberScalarWhereWithAggregatesInput = {
    AND?: FamilyGroupMemberScalarWhereWithAggregatesInput | FamilyGroupMemberScalarWhereWithAggregatesInput[]
    OR?: FamilyGroupMemberScalarWhereWithAggregatesInput[]
    NOT?: FamilyGroupMemberScalarWhereWithAggregatesInput | FamilyGroupMemberScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"FamilyGroupMember"> | string
    groupId?: StringWithAggregatesFilter<"FamilyGroupMember"> | string
    userId?: StringWithAggregatesFilter<"FamilyGroupMember"> | string
    role?: EnumFamilyMemberRoleWithAggregatesFilter<"FamilyGroupMember"> | $Enums.FamilyMemberRole
    joinedAt?: DateTimeWithAggregatesFilter<"FamilyGroupMember"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"FamilyGroupMember"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"FamilyGroupMember"> | Date | string
  }

  export type SubscriptionWhereInput = {
    AND?: SubscriptionWhereInput | SubscriptionWhereInput[]
    OR?: SubscriptionWhereInput[]
    NOT?: SubscriptionWhereInput | SubscriptionWhereInput[]
    id?: StringFilter<"Subscription"> | string
    userId?: StringFilter<"Subscription"> | string
    familyGroupId?: StringNullableFilter<"Subscription"> | string | null
    stripeId?: StringNullableFilter<"Subscription"> | string | null
    tier?: EnumSubscriptionTierFilter<"Subscription"> | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFilter<"Subscription"> | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFilter<"Subscription"> | Date | string
    currentPeriodEnd?: DateTimeFilter<"Subscription"> | Date | string
    cancelAtPeriodEnd?: BoolFilter<"Subscription"> | boolean
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    familyGroup?: XOR<FamilyGroupNullableRelationFilter, FamilyGroupWhereInput> | null
    watchlistItems?: WatchlistItemListRelationFilter
    exposures?: ExposureListRelationFilter
    alerts?: AlertListRelationFilter
  }

  export type SubscriptionOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    familyGroupId?: SortOrderInput | SortOrder
    stripeId?: SortOrderInput | SortOrder
    tier?: SortOrder
    status?: SortOrder
    currentPeriodStart?: SortOrder
    currentPeriodEnd?: SortOrder
    cancelAtPeriodEnd?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    familyGroup?: FamilyGroupOrderByWithRelationInput
    watchlistItems?: WatchlistItemOrderByRelationAggregateInput
    exposures?: ExposureOrderByRelationAggregateInput
    alerts?: AlertOrderByRelationAggregateInput
  }

  export type SubscriptionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    stripeId?: string
    AND?: SubscriptionWhereInput | SubscriptionWhereInput[]
    OR?: SubscriptionWhereInput[]
    NOT?: SubscriptionWhereInput | SubscriptionWhereInput[]
    userId?: StringFilter<"Subscription"> | string
    familyGroupId?: StringNullableFilter<"Subscription"> | string | null
    tier?: EnumSubscriptionTierFilter<"Subscription"> | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFilter<"Subscription"> | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFilter<"Subscription"> | Date | string
    currentPeriodEnd?: DateTimeFilter<"Subscription"> | Date | string
    cancelAtPeriodEnd?: BoolFilter<"Subscription"> | boolean
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    familyGroup?: XOR<FamilyGroupNullableRelationFilter, FamilyGroupWhereInput> | null
    watchlistItems?: WatchlistItemListRelationFilter
    exposures?: ExposureListRelationFilter
    alerts?: AlertListRelationFilter
  }, "id" | "stripeId">

  export type SubscriptionOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    familyGroupId?: SortOrderInput | SortOrder
    stripeId?: SortOrderInput | SortOrder
    tier?: SortOrder
    status?: SortOrder
    currentPeriodStart?: SortOrder
    currentPeriodEnd?: SortOrder
    cancelAtPeriodEnd?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SubscriptionCountOrderByAggregateInput
    _max?: SubscriptionMaxOrderByAggregateInput
    _min?: SubscriptionMinOrderByAggregateInput
  }

  export type SubscriptionScalarWhereWithAggregatesInput = {
    AND?: SubscriptionScalarWhereWithAggregatesInput | SubscriptionScalarWhereWithAggregatesInput[]
    OR?: SubscriptionScalarWhereWithAggregatesInput[]
    NOT?: SubscriptionScalarWhereWithAggregatesInput | SubscriptionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Subscription"> | string
    userId?: StringWithAggregatesFilter<"Subscription"> | string
    familyGroupId?: StringNullableWithAggregatesFilter<"Subscription"> | string | null
    stripeId?: StringNullableWithAggregatesFilter<"Subscription"> | string | null
    tier?: EnumSubscriptionTierWithAggregatesFilter<"Subscription"> | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusWithAggregatesFilter<"Subscription"> | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    currentPeriodEnd?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    cancelAtPeriodEnd?: BoolWithAggregatesFilter<"Subscription"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
  }

  export type WatchlistItemWhereInput = {
    AND?: WatchlistItemWhereInput | WatchlistItemWhereInput[]
    OR?: WatchlistItemWhereInput[]
    NOT?: WatchlistItemWhereInput | WatchlistItemWhereInput[]
    id?: StringFilter<"WatchlistItem"> | string
    subscriptionId?: StringFilter<"WatchlistItem"> | string
    type?: EnumWatchlistTypeFilter<"WatchlistItem"> | $Enums.WatchlistType
    value?: StringFilter<"WatchlistItem"> | string
    hash?: StringFilter<"WatchlistItem"> | string
    isActive?: BoolFilter<"WatchlistItem"> | boolean
    createdAt?: DateTimeFilter<"WatchlistItem"> | Date | string
    updatedAt?: DateTimeFilter<"WatchlistItem"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    exposures?: ExposureListRelationFilter
  }

  export type WatchlistItemOrderByWithRelationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    hash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    subscription?: SubscriptionOrderByWithRelationInput
    exposures?: ExposureOrderByRelationAggregateInput
  }

  export type WatchlistItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    subscriptionId_type_hash?: WatchlistItemSubscriptionIdTypeHashCompoundUniqueInput
    AND?: WatchlistItemWhereInput | WatchlistItemWhereInput[]
    OR?: WatchlistItemWhereInput[]
    NOT?: WatchlistItemWhereInput | WatchlistItemWhereInput[]
    subscriptionId?: StringFilter<"WatchlistItem"> | string
    type?: EnumWatchlistTypeFilter<"WatchlistItem"> | $Enums.WatchlistType
    value?: StringFilter<"WatchlistItem"> | string
    hash?: StringFilter<"WatchlistItem"> | string
    isActive?: BoolFilter<"WatchlistItem"> | boolean
    createdAt?: DateTimeFilter<"WatchlistItem"> | Date | string
    updatedAt?: DateTimeFilter<"WatchlistItem"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    exposures?: ExposureListRelationFilter
  }, "id" | "subscriptionId_type_hash">

  export type WatchlistItemOrderByWithAggregationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    hash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: WatchlistItemCountOrderByAggregateInput
    _max?: WatchlistItemMaxOrderByAggregateInput
    _min?: WatchlistItemMinOrderByAggregateInput
  }

  export type WatchlistItemScalarWhereWithAggregatesInput = {
    AND?: WatchlistItemScalarWhereWithAggregatesInput | WatchlistItemScalarWhereWithAggregatesInput[]
    OR?: WatchlistItemScalarWhereWithAggregatesInput[]
    NOT?: WatchlistItemScalarWhereWithAggregatesInput | WatchlistItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WatchlistItem"> | string
    subscriptionId?: StringWithAggregatesFilter<"WatchlistItem"> | string
    type?: EnumWatchlistTypeWithAggregatesFilter<"WatchlistItem"> | $Enums.WatchlistType
    value?: StringWithAggregatesFilter<"WatchlistItem"> | string
    hash?: StringWithAggregatesFilter<"WatchlistItem"> | string
    isActive?: BoolWithAggregatesFilter<"WatchlistItem"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"WatchlistItem"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"WatchlistItem"> | Date | string
  }

  export type ExposureWhereInput = {
    AND?: ExposureWhereInput | ExposureWhereInput[]
    OR?: ExposureWhereInput[]
    NOT?: ExposureWhereInput | ExposureWhereInput[]
    id?: StringFilter<"Exposure"> | string
    subscriptionId?: StringFilter<"Exposure"> | string
    watchlistItemId?: StringNullableFilter<"Exposure"> | string | null
    source?: EnumExposureSourceFilter<"Exposure"> | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFilter<"Exposure"> | $Enums.WatchlistType
    identifier?: StringFilter<"Exposure"> | string
    identifierHash?: StringFilter<"Exposure"> | string
    severity?: EnumExposureSeverityFilter<"Exposure"> | $Enums.ExposureSeverity
    metadata?: JsonNullableFilter<"Exposure">
    isFirstTime?: BoolFilter<"Exposure"> | boolean
    detectedAt?: DateTimeFilter<"Exposure"> | Date | string
    createdAt?: DateTimeFilter<"Exposure"> | Date | string
    updatedAt?: DateTimeFilter<"Exposure"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    watchlistItem?: XOR<WatchlistItemNullableRelationFilter, WatchlistItemWhereInput> | null
    alerts?: AlertListRelationFilter
  }

  export type ExposureOrderByWithRelationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    watchlistItemId?: SortOrderInput | SortOrder
    source?: SortOrder
    dataType?: SortOrder
    identifier?: SortOrder
    identifierHash?: SortOrder
    severity?: SortOrder
    metadata?: SortOrderInput | SortOrder
    isFirstTime?: SortOrder
    detectedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    subscription?: SubscriptionOrderByWithRelationInput
    watchlistItem?: WatchlistItemOrderByWithRelationInput
    alerts?: AlertOrderByRelationAggregateInput
  }

  export type ExposureWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ExposureWhereInput | ExposureWhereInput[]
    OR?: ExposureWhereInput[]
    NOT?: ExposureWhereInput | ExposureWhereInput[]
    subscriptionId?: StringFilter<"Exposure"> | string
    watchlistItemId?: StringNullableFilter<"Exposure"> | string | null
    source?: EnumExposureSourceFilter<"Exposure"> | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFilter<"Exposure"> | $Enums.WatchlistType
    identifier?: StringFilter<"Exposure"> | string
    identifierHash?: StringFilter<"Exposure"> | string
    severity?: EnumExposureSeverityFilter<"Exposure"> | $Enums.ExposureSeverity
    metadata?: JsonNullableFilter<"Exposure">
    isFirstTime?: BoolFilter<"Exposure"> | boolean
    detectedAt?: DateTimeFilter<"Exposure"> | Date | string
    createdAt?: DateTimeFilter<"Exposure"> | Date | string
    updatedAt?: DateTimeFilter<"Exposure"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    watchlistItem?: XOR<WatchlistItemNullableRelationFilter, WatchlistItemWhereInput> | null
    alerts?: AlertListRelationFilter
  }, "id">

  export type ExposureOrderByWithAggregationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    watchlistItemId?: SortOrderInput | SortOrder
    source?: SortOrder
    dataType?: SortOrder
    identifier?: SortOrder
    identifierHash?: SortOrder
    severity?: SortOrder
    metadata?: SortOrderInput | SortOrder
    isFirstTime?: SortOrder
    detectedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: ExposureCountOrderByAggregateInput
    _max?: ExposureMaxOrderByAggregateInput
    _min?: ExposureMinOrderByAggregateInput
  }

  export type ExposureScalarWhereWithAggregatesInput = {
    AND?: ExposureScalarWhereWithAggregatesInput | ExposureScalarWhereWithAggregatesInput[]
    OR?: ExposureScalarWhereWithAggregatesInput[]
    NOT?: ExposureScalarWhereWithAggregatesInput | ExposureScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Exposure"> | string
    subscriptionId?: StringWithAggregatesFilter<"Exposure"> | string
    watchlistItemId?: StringNullableWithAggregatesFilter<"Exposure"> | string | null
    source?: EnumExposureSourceWithAggregatesFilter<"Exposure"> | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeWithAggregatesFilter<"Exposure"> | $Enums.WatchlistType
    identifier?: StringWithAggregatesFilter<"Exposure"> | string
    identifierHash?: StringWithAggregatesFilter<"Exposure"> | string
    severity?: EnumExposureSeverityWithAggregatesFilter<"Exposure"> | $Enums.ExposureSeverity
    metadata?: JsonNullableWithAggregatesFilter<"Exposure">
    isFirstTime?: BoolWithAggregatesFilter<"Exposure"> | boolean
    detectedAt?: DateTimeWithAggregatesFilter<"Exposure"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Exposure"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Exposure"> | Date | string
  }

  export type AlertWhereInput = {
    AND?: AlertWhereInput | AlertWhereInput[]
    OR?: AlertWhereInput[]
    NOT?: AlertWhereInput | AlertWhereInput[]
    id?: StringFilter<"Alert"> | string
    subscriptionId?: StringFilter<"Alert"> | string
    userId?: StringFilter<"Alert"> | string
    exposureId?: StringNullableFilter<"Alert"> | string | null
    type?: EnumAlertTypeFilter<"Alert"> | $Enums.AlertType
    title?: StringFilter<"Alert"> | string
    message?: StringFilter<"Alert"> | string
    severity?: EnumAlertSeverityFilter<"Alert"> | $Enums.AlertSeverity
    isRead?: BoolFilter<"Alert"> | boolean
    readAt?: DateTimeNullableFilter<"Alert"> | Date | string | null
    channel?: EnumAlertChannelNullableListFilter<"Alert">
    createdAt?: DateTimeFilter<"Alert"> | Date | string
    updatedAt?: DateTimeFilter<"Alert"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
    exposure?: XOR<ExposureNullableRelationFilter, ExposureWhereInput> | null
  }

  export type AlertOrderByWithRelationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    userId?: SortOrder
    exposureId?: SortOrderInput | SortOrder
    type?: SortOrder
    title?: SortOrder
    message?: SortOrder
    severity?: SortOrder
    isRead?: SortOrder
    readAt?: SortOrderInput | SortOrder
    channel?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    subscription?: SubscriptionOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    exposure?: ExposureOrderByWithRelationInput
  }

  export type AlertWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AlertWhereInput | AlertWhereInput[]
    OR?: AlertWhereInput[]
    NOT?: AlertWhereInput | AlertWhereInput[]
    subscriptionId?: StringFilter<"Alert"> | string
    userId?: StringFilter<"Alert"> | string
    exposureId?: StringNullableFilter<"Alert"> | string | null
    type?: EnumAlertTypeFilter<"Alert"> | $Enums.AlertType
    title?: StringFilter<"Alert"> | string
    message?: StringFilter<"Alert"> | string
    severity?: EnumAlertSeverityFilter<"Alert"> | $Enums.AlertSeverity
    isRead?: BoolFilter<"Alert"> | boolean
    readAt?: DateTimeNullableFilter<"Alert"> | Date | string | null
    channel?: EnumAlertChannelNullableListFilter<"Alert">
    createdAt?: DateTimeFilter<"Alert"> | Date | string
    updatedAt?: DateTimeFilter<"Alert"> | Date | string
    subscription?: XOR<SubscriptionRelationFilter, SubscriptionWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
    exposure?: XOR<ExposureNullableRelationFilter, ExposureWhereInput> | null
  }, "id">

  export type AlertOrderByWithAggregationInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    userId?: SortOrder
    exposureId?: SortOrderInput | SortOrder
    type?: SortOrder
    title?: SortOrder
    message?: SortOrder
    severity?: SortOrder
    isRead?: SortOrder
    readAt?: SortOrderInput | SortOrder
    channel?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AlertCountOrderByAggregateInput
    _max?: AlertMaxOrderByAggregateInput
    _min?: AlertMinOrderByAggregateInput
  }

  export type AlertScalarWhereWithAggregatesInput = {
    AND?: AlertScalarWhereWithAggregatesInput | AlertScalarWhereWithAggregatesInput[]
    OR?: AlertScalarWhereWithAggregatesInput[]
    NOT?: AlertScalarWhereWithAggregatesInput | AlertScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Alert"> | string
    subscriptionId?: StringWithAggregatesFilter<"Alert"> | string
    userId?: StringWithAggregatesFilter<"Alert"> | string
    exposureId?: StringNullableWithAggregatesFilter<"Alert"> | string | null
    type?: EnumAlertTypeWithAggregatesFilter<"Alert"> | $Enums.AlertType
    title?: StringWithAggregatesFilter<"Alert"> | string
    message?: StringWithAggregatesFilter<"Alert"> | string
    severity?: EnumAlertSeverityWithAggregatesFilter<"Alert"> | $Enums.AlertSeverity
    isRead?: BoolWithAggregatesFilter<"Alert"> | boolean
    readAt?: DateTimeNullableWithAggregatesFilter<"Alert"> | Date | string | null
    channel?: EnumAlertChannelNullableListFilter<"Alert">
    createdAt?: DateTimeWithAggregatesFilter<"Alert"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Alert"> | Date | string
  }

  export type VoiceEnrollmentWhereInput = {
    AND?: VoiceEnrollmentWhereInput | VoiceEnrollmentWhereInput[]
    OR?: VoiceEnrollmentWhereInput[]
    NOT?: VoiceEnrollmentWhereInput | VoiceEnrollmentWhereInput[]
    id?: StringFilter<"VoiceEnrollment"> | string
    userId?: StringFilter<"VoiceEnrollment"> | string
    name?: StringFilter<"VoiceEnrollment"> | string
    voiceHash?: StringFilter<"VoiceEnrollment"> | string
    audioMetadata?: JsonNullableFilter<"VoiceEnrollment">
    isActive?: BoolFilter<"VoiceEnrollment"> | boolean
    createdAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
    updatedAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    analyses?: VoiceAnalysisListRelationFilter
  }

  export type VoiceEnrollmentOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    voiceHash?: SortOrder
    audioMetadata?: SortOrderInput | SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    analyses?: VoiceAnalysisOrderByRelationAggregateInput
  }

  export type VoiceEnrollmentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VoiceEnrollmentWhereInput | VoiceEnrollmentWhereInput[]
    OR?: VoiceEnrollmentWhereInput[]
    NOT?: VoiceEnrollmentWhereInput | VoiceEnrollmentWhereInput[]
    userId?: StringFilter<"VoiceEnrollment"> | string
    name?: StringFilter<"VoiceEnrollment"> | string
    voiceHash?: StringFilter<"VoiceEnrollment"> | string
    audioMetadata?: JsonNullableFilter<"VoiceEnrollment">
    isActive?: BoolFilter<"VoiceEnrollment"> | boolean
    createdAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
    updatedAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    analyses?: VoiceAnalysisListRelationFilter
  }, "id">

  export type VoiceEnrollmentOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    voiceHash?: SortOrder
    audioMetadata?: SortOrderInput | SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: VoiceEnrollmentCountOrderByAggregateInput
    _max?: VoiceEnrollmentMaxOrderByAggregateInput
    _min?: VoiceEnrollmentMinOrderByAggregateInput
  }

  export type VoiceEnrollmentScalarWhereWithAggregatesInput = {
    AND?: VoiceEnrollmentScalarWhereWithAggregatesInput | VoiceEnrollmentScalarWhereWithAggregatesInput[]
    OR?: VoiceEnrollmentScalarWhereWithAggregatesInput[]
    NOT?: VoiceEnrollmentScalarWhereWithAggregatesInput | VoiceEnrollmentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"VoiceEnrollment"> | string
    userId?: StringWithAggregatesFilter<"VoiceEnrollment"> | string
    name?: StringWithAggregatesFilter<"VoiceEnrollment"> | string
    voiceHash?: StringWithAggregatesFilter<"VoiceEnrollment"> | string
    audioMetadata?: JsonNullableWithAggregatesFilter<"VoiceEnrollment">
    isActive?: BoolWithAggregatesFilter<"VoiceEnrollment"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"VoiceEnrollment"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"VoiceEnrollment"> | Date | string
  }

  export type VoiceAnalysisWhereInput = {
    AND?: VoiceAnalysisWhereInput | VoiceAnalysisWhereInput[]
    OR?: VoiceAnalysisWhereInput[]
    NOT?: VoiceAnalysisWhereInput | VoiceAnalysisWhereInput[]
    id?: StringFilter<"VoiceAnalysis"> | string
    enrollmentId?: StringNullableFilter<"VoiceAnalysis"> | string | null
    userId?: StringFilter<"VoiceAnalysis"> | string
    audioHash?: StringFilter<"VoiceAnalysis"> | string
    isSynthetic?: BoolFilter<"VoiceAnalysis"> | boolean
    confidence?: FloatFilter<"VoiceAnalysis"> | number
    analysisResult?: JsonFilter<"VoiceAnalysis">
    audioUrl?: StringFilter<"VoiceAnalysis"> | string
    createdAt?: DateTimeFilter<"VoiceAnalysis"> | Date | string
    enrollment?: XOR<VoiceEnrollmentNullableRelationFilter, VoiceEnrollmentWhereInput> | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type VoiceAnalysisOrderByWithRelationInput = {
    id?: SortOrder
    enrollmentId?: SortOrderInput | SortOrder
    userId?: SortOrder
    audioHash?: SortOrder
    isSynthetic?: SortOrder
    confidence?: SortOrder
    analysisResult?: SortOrder
    audioUrl?: SortOrder
    createdAt?: SortOrder
    enrollment?: VoiceEnrollmentOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type VoiceAnalysisWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VoiceAnalysisWhereInput | VoiceAnalysisWhereInput[]
    OR?: VoiceAnalysisWhereInput[]
    NOT?: VoiceAnalysisWhereInput | VoiceAnalysisWhereInput[]
    enrollmentId?: StringNullableFilter<"VoiceAnalysis"> | string | null
    userId?: StringFilter<"VoiceAnalysis"> | string
    audioHash?: StringFilter<"VoiceAnalysis"> | string
    isSynthetic?: BoolFilter<"VoiceAnalysis"> | boolean
    confidence?: FloatFilter<"VoiceAnalysis"> | number
    analysisResult?: JsonFilter<"VoiceAnalysis">
    audioUrl?: StringFilter<"VoiceAnalysis"> | string
    createdAt?: DateTimeFilter<"VoiceAnalysis"> | Date | string
    enrollment?: XOR<VoiceEnrollmentNullableRelationFilter, VoiceEnrollmentWhereInput> | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type VoiceAnalysisOrderByWithAggregationInput = {
    id?: SortOrder
    enrollmentId?: SortOrderInput | SortOrder
    userId?: SortOrder
    audioHash?: SortOrder
    isSynthetic?: SortOrder
    confidence?: SortOrder
    analysisResult?: SortOrder
    audioUrl?: SortOrder
    createdAt?: SortOrder
    _count?: VoiceAnalysisCountOrderByAggregateInput
    _avg?: VoiceAnalysisAvgOrderByAggregateInput
    _max?: VoiceAnalysisMaxOrderByAggregateInput
    _min?: VoiceAnalysisMinOrderByAggregateInput
    _sum?: VoiceAnalysisSumOrderByAggregateInput
  }

  export type VoiceAnalysisScalarWhereWithAggregatesInput = {
    AND?: VoiceAnalysisScalarWhereWithAggregatesInput | VoiceAnalysisScalarWhereWithAggregatesInput[]
    OR?: VoiceAnalysisScalarWhereWithAggregatesInput[]
    NOT?: VoiceAnalysisScalarWhereWithAggregatesInput | VoiceAnalysisScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"VoiceAnalysis"> | string
    enrollmentId?: StringNullableWithAggregatesFilter<"VoiceAnalysis"> | string | null
    userId?: StringWithAggregatesFilter<"VoiceAnalysis"> | string
    audioHash?: StringWithAggregatesFilter<"VoiceAnalysis"> | string
    isSynthetic?: BoolWithAggregatesFilter<"VoiceAnalysis"> | boolean
    confidence?: FloatWithAggregatesFilter<"VoiceAnalysis"> | number
    analysisResult?: JsonWithAggregatesFilter<"VoiceAnalysis">
    audioUrl?: StringWithAggregatesFilter<"VoiceAnalysis"> | string
    createdAt?: DateTimeWithAggregatesFilter<"VoiceAnalysis"> | Date | string
  }

  export type SpamFeedbackWhereInput = {
    AND?: SpamFeedbackWhereInput | SpamFeedbackWhereInput[]
    OR?: SpamFeedbackWhereInput[]
    NOT?: SpamFeedbackWhereInput | SpamFeedbackWhereInput[]
    id?: StringFilter<"SpamFeedback"> | string
    userId?: StringFilter<"SpamFeedback"> | string
    phoneNumber?: StringFilter<"SpamFeedback"> | string
    phoneNumberHash?: StringFilter<"SpamFeedback"> | string
    isSpam?: BoolFilter<"SpamFeedback"> | boolean
    confidence?: FloatNullableFilter<"SpamFeedback"> | number | null
    feedbackType?: EnumFeedbackTypeFilter<"SpamFeedback"> | $Enums.FeedbackType
    metadata?: JsonNullableFilter<"SpamFeedback">
    createdAt?: DateTimeFilter<"SpamFeedback"> | Date | string
    updatedAt?: DateTimeFilter<"SpamFeedback"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type SpamFeedbackOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    phoneNumber?: SortOrder
    phoneNumberHash?: SortOrder
    isSpam?: SortOrder
    confidence?: SortOrderInput | SortOrder
    feedbackType?: SortOrder
    metadata?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SpamFeedbackWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SpamFeedbackWhereInput | SpamFeedbackWhereInput[]
    OR?: SpamFeedbackWhereInput[]
    NOT?: SpamFeedbackWhereInput | SpamFeedbackWhereInput[]
    userId?: StringFilter<"SpamFeedback"> | string
    phoneNumber?: StringFilter<"SpamFeedback"> | string
    phoneNumberHash?: StringFilter<"SpamFeedback"> | string
    isSpam?: BoolFilter<"SpamFeedback"> | boolean
    confidence?: FloatNullableFilter<"SpamFeedback"> | number | null
    feedbackType?: EnumFeedbackTypeFilter<"SpamFeedback"> | $Enums.FeedbackType
    metadata?: JsonNullableFilter<"SpamFeedback">
    createdAt?: DateTimeFilter<"SpamFeedback"> | Date | string
    updatedAt?: DateTimeFilter<"SpamFeedback"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type SpamFeedbackOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    phoneNumber?: SortOrder
    phoneNumberHash?: SortOrder
    isSpam?: SortOrder
    confidence?: SortOrderInput | SortOrder
    feedbackType?: SortOrder
    metadata?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SpamFeedbackCountOrderByAggregateInput
    _avg?: SpamFeedbackAvgOrderByAggregateInput
    _max?: SpamFeedbackMaxOrderByAggregateInput
    _min?: SpamFeedbackMinOrderByAggregateInput
    _sum?: SpamFeedbackSumOrderByAggregateInput
  }

  export type SpamFeedbackScalarWhereWithAggregatesInput = {
    AND?: SpamFeedbackScalarWhereWithAggregatesInput | SpamFeedbackScalarWhereWithAggregatesInput[]
    OR?: SpamFeedbackScalarWhereWithAggregatesInput[]
    NOT?: SpamFeedbackScalarWhereWithAggregatesInput | SpamFeedbackScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SpamFeedback"> | string
    userId?: StringWithAggregatesFilter<"SpamFeedback"> | string
    phoneNumber?: StringWithAggregatesFilter<"SpamFeedback"> | string
    phoneNumberHash?: StringWithAggregatesFilter<"SpamFeedback"> | string
    isSpam?: BoolWithAggregatesFilter<"SpamFeedback"> | boolean
    confidence?: FloatNullableWithAggregatesFilter<"SpamFeedback"> | number | null
    feedbackType?: EnumFeedbackTypeWithAggregatesFilter<"SpamFeedback"> | $Enums.FeedbackType
    metadata?: JsonNullableWithAggregatesFilter<"SpamFeedback">
    createdAt?: DateTimeWithAggregatesFilter<"SpamFeedback"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"SpamFeedback"> | Date | string
  }

  export type SpamRuleWhereInput = {
    AND?: SpamRuleWhereInput | SpamRuleWhereInput[]
    OR?: SpamRuleWhereInput[]
    NOT?: SpamRuleWhereInput | SpamRuleWhereInput[]
    id?: StringFilter<"SpamRule"> | string
    userId?: StringNullableFilter<"SpamRule"> | string | null
    isGlobal?: BoolFilter<"SpamRule"> | boolean
    ruleType?: EnumRuleTypeFilter<"SpamRule"> | $Enums.RuleType
    pattern?: StringFilter<"SpamRule"> | string
    action?: EnumRuleActionFilter<"SpamRule"> | $Enums.RuleAction
    priority?: IntFilter<"SpamRule"> | number
    isActive?: BoolFilter<"SpamRule"> | boolean
    createdAt?: DateTimeFilter<"SpamRule"> | Date | string
    updatedAt?: DateTimeFilter<"SpamRule"> | Date | string
    user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type SpamRuleOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    isGlobal?: SortOrder
    ruleType?: SortOrder
    pattern?: SortOrder
    action?: SortOrder
    priority?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SpamRuleWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SpamRuleWhereInput | SpamRuleWhereInput[]
    OR?: SpamRuleWhereInput[]
    NOT?: SpamRuleWhereInput | SpamRuleWhereInput[]
    userId?: StringNullableFilter<"SpamRule"> | string | null
    isGlobal?: BoolFilter<"SpamRule"> | boolean
    ruleType?: EnumRuleTypeFilter<"SpamRule"> | $Enums.RuleType
    pattern?: StringFilter<"SpamRule"> | string
    action?: EnumRuleActionFilter<"SpamRule"> | $Enums.RuleAction
    priority?: IntFilter<"SpamRule"> | number
    isActive?: BoolFilter<"SpamRule"> | boolean
    createdAt?: DateTimeFilter<"SpamRule"> | Date | string
    updatedAt?: DateTimeFilter<"SpamRule"> | Date | string
    user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type SpamRuleOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    isGlobal?: SortOrder
    ruleType?: SortOrder
    pattern?: SortOrder
    action?: SortOrder
    priority?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SpamRuleCountOrderByAggregateInput
    _avg?: SpamRuleAvgOrderByAggregateInput
    _max?: SpamRuleMaxOrderByAggregateInput
    _min?: SpamRuleMinOrderByAggregateInput
    _sum?: SpamRuleSumOrderByAggregateInput
  }

  export type SpamRuleScalarWhereWithAggregatesInput = {
    AND?: SpamRuleScalarWhereWithAggregatesInput | SpamRuleScalarWhereWithAggregatesInput[]
    OR?: SpamRuleScalarWhereWithAggregatesInput[]
    NOT?: SpamRuleScalarWhereWithAggregatesInput | SpamRuleScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SpamRule"> | string
    userId?: StringNullableWithAggregatesFilter<"SpamRule"> | string | null
    isGlobal?: BoolWithAggregatesFilter<"SpamRule"> | boolean
    ruleType?: EnumRuleTypeWithAggregatesFilter<"SpamRule"> | $Enums.RuleType
    pattern?: StringWithAggregatesFilter<"SpamRule"> | string
    action?: EnumRuleActionWithAggregatesFilter<"SpamRule"> | $Enums.RuleAction
    priority?: IntWithAggregatesFilter<"SpamRule"> | number
    isActive?: BoolWithAggregatesFilter<"SpamRule"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"SpamRule"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"SpamRule"> | Date | string
  }

  export type AuditLogWhereInput = {
    AND?: AuditLogWhereInput | AuditLogWhereInput[]
    OR?: AuditLogWhereInput[]
    NOT?: AuditLogWhereInput | AuditLogWhereInput[]
    id?: StringFilter<"AuditLog"> | string
    userId?: StringNullableFilter<"AuditLog"> | string | null
    action?: StringFilter<"AuditLog"> | string
    resource?: StringFilter<"AuditLog"> | string
    resourceId?: StringNullableFilter<"AuditLog"> | string | null
    changes?: JsonNullableFilter<"AuditLog">
    metadata?: JsonNullableFilter<"AuditLog">
    ipAddress?: StringNullableFilter<"AuditLog"> | string | null
    userAgent?: StringNullableFilter<"AuditLog"> | string | null
    createdAt?: DateTimeFilter<"AuditLog"> | Date | string
  }

  export type AuditLogOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    action?: SortOrder
    resource?: SortOrder
    resourceId?: SortOrderInput | SortOrder
    changes?: SortOrderInput | SortOrder
    metadata?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
  }

  export type AuditLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AuditLogWhereInput | AuditLogWhereInput[]
    OR?: AuditLogWhereInput[]
    NOT?: AuditLogWhereInput | AuditLogWhereInput[]
    userId?: StringNullableFilter<"AuditLog"> | string | null
    action?: StringFilter<"AuditLog"> | string
    resource?: StringFilter<"AuditLog"> | string
    resourceId?: StringNullableFilter<"AuditLog"> | string | null
    changes?: JsonNullableFilter<"AuditLog">
    metadata?: JsonNullableFilter<"AuditLog">
    ipAddress?: StringNullableFilter<"AuditLog"> | string | null
    userAgent?: StringNullableFilter<"AuditLog"> | string | null
    createdAt?: DateTimeFilter<"AuditLog"> | Date | string
  }, "id">

  export type AuditLogOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    action?: SortOrder
    resource?: SortOrder
    resourceId?: SortOrderInput | SortOrder
    changes?: SortOrderInput | SortOrder
    metadata?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: AuditLogCountOrderByAggregateInput
    _max?: AuditLogMaxOrderByAggregateInput
    _min?: AuditLogMinOrderByAggregateInput
  }

  export type AuditLogScalarWhereWithAggregatesInput = {
    AND?: AuditLogScalarWhereWithAggregatesInput | AuditLogScalarWhereWithAggregatesInput[]
    OR?: AuditLogScalarWhereWithAggregatesInput[]
    NOT?: AuditLogScalarWhereWithAggregatesInput | AuditLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AuditLog"> | string
    userId?: StringNullableWithAggregatesFilter<"AuditLog"> | string | null
    action?: StringWithAggregatesFilter<"AuditLog"> | string
    resource?: StringWithAggregatesFilter<"AuditLog"> | string
    resourceId?: StringNullableWithAggregatesFilter<"AuditLog"> | string | null
    changes?: JsonNullableWithAggregatesFilter<"AuditLog">
    metadata?: JsonNullableWithAggregatesFilter<"AuditLog">
    ipAddress?: StringNullableWithAggregatesFilter<"AuditLog"> | string | null
    userAgent?: StringNullableWithAggregatesFilter<"AuditLog"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"AuditLog"> | Date | string
  }

  export type KPISnapshotWhereInput = {
    AND?: KPISnapshotWhereInput | KPISnapshotWhereInput[]
    OR?: KPISnapshotWhereInput[]
    NOT?: KPISnapshotWhereInput | KPISnapshotWhereInput[]
    id?: StringFilter<"KPISnapshot"> | string
    date?: DateTimeFilter<"KPISnapshot"> | Date | string
    metricName?: StringFilter<"KPISnapshot"> | string
    metricValue?: FloatFilter<"KPISnapshot"> | number
    metadata?: JsonNullableFilter<"KPISnapshot">
    createdAt?: DateTimeFilter<"KPISnapshot"> | Date | string
  }

  export type KPISnapshotOrderByWithRelationInput = {
    id?: SortOrder
    date?: SortOrder
    metricName?: SortOrder
    metricValue?: SortOrder
    metadata?: SortOrderInput | SortOrder
    createdAt?: SortOrder
  }

  export type KPISnapshotWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    date?: Date | string
    AND?: KPISnapshotWhereInput | KPISnapshotWhereInput[]
    OR?: KPISnapshotWhereInput[]
    NOT?: KPISnapshotWhereInput | KPISnapshotWhereInput[]
    metricName?: StringFilter<"KPISnapshot"> | string
    metricValue?: FloatFilter<"KPISnapshot"> | number
    metadata?: JsonNullableFilter<"KPISnapshot">
    createdAt?: DateTimeFilter<"KPISnapshot"> | Date | string
  }, "id" | "date">

  export type KPISnapshotOrderByWithAggregationInput = {
    id?: SortOrder
    date?: SortOrder
    metricName?: SortOrder
    metricValue?: SortOrder
    metadata?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: KPISnapshotCountOrderByAggregateInput
    _avg?: KPISnapshotAvgOrderByAggregateInput
    _max?: KPISnapshotMaxOrderByAggregateInput
    _min?: KPISnapshotMinOrderByAggregateInput
    _sum?: KPISnapshotSumOrderByAggregateInput
  }

  export type KPISnapshotScalarWhereWithAggregatesInput = {
    AND?: KPISnapshotScalarWhereWithAggregatesInput | KPISnapshotScalarWhereWithAggregatesInput[]
    OR?: KPISnapshotScalarWhereWithAggregatesInput[]
    NOT?: KPISnapshotScalarWhereWithAggregatesInput | KPISnapshotScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"KPISnapshot"> | string
    date?: DateTimeWithAggregatesFilter<"KPISnapshot"> | Date | string
    metricName?: StringWithAggregatesFilter<"KPISnapshot"> | string
    metricValue?: FloatWithAggregatesFilter<"KPISnapshot"> | number
    metadata?: JsonNullableWithAggregatesFilter<"KPISnapshot">
    createdAt?: DateTimeWithAggregatesFilter<"KPISnapshot"> | Date | string
  }

  export type UserCreateInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountCreateInput = {
    id?: string
    provider: string
    providerAccountId: string
    access_token?: string | null
    refresh_token?: string | null
    expires_at?: number | null
    token_type?: string | null
    scope?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAccountsInput
  }

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

  export type AccountUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

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

  export type AccountUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSessionsInput
  }

  export type SessionUncheckedCreateInput = {
    id?: string
    userId: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type SessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateManyInput = {
    id?: string
    userId: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupCreateInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    owner: UserCreateNestedOneWithoutFamilyGroupOwnedInput
    members?: FamilyGroupMemberCreateNestedManyWithoutGroupInput
    subscriptions?: SubscriptionCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupUncheckedCreateInput = {
    id?: string
    name: string
    ownerId: string
    createdAt?: Date | string
    updatedAt?: Date | string
    members?: FamilyGroupMemberUncheckedCreateNestedManyWithoutGroupInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    owner?: UserUpdateOneRequiredWithoutFamilyGroupOwnedNestedInput
    members?: FamilyGroupMemberUpdateManyWithoutGroupNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutFamilyGroupNestedInput
  }

  export type FamilyGroupUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    ownerId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    members?: FamilyGroupMemberUncheckedUpdateManyWithoutGroupNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutFamilyGroupNestedInput
  }

  export type FamilyGroupCreateManyInput = {
    id?: string
    name: string
    ownerId: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    ownerId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberCreateInput = {
    id?: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    group: FamilyGroupCreateNestedOneWithoutMembersInput
    user: UserCreateNestedOneWithoutFamilyGroupsInput
  }

  export type FamilyGroupMemberUncheckedCreateInput = {
    id?: string
    groupId: string
    userId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    group?: FamilyGroupUpdateOneRequiredWithoutMembersNestedInput
    user?: UserUpdateOneRequiredWithoutFamilyGroupsNestedInput
  }

  export type FamilyGroupMemberUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberCreateManyInput = {
    id?: string
    groupId: string
    userId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionCreateInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
    familyGroup?: FamilyGroupCreateNestedOneWithoutSubscriptionsInput
    watchlistItems?: WatchlistItemCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateInput = {
    id?: string
    userId: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItems?: WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureUncheckedCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
    familyGroup?: FamilyGroupUpdateOneWithoutSubscriptionsNestedInput
    watchlistItems?: WatchlistItemUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItems?: WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionCreateManyInput = {
    id?: string
    userId: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SubscriptionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WatchlistItemCreateInput = {
    id?: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutWatchlistItemsInput
    exposures?: ExposureCreateNestedManyWithoutWatchlistItemInput
  }

  export type WatchlistItemUncheckedCreateInput = {
    id?: string
    subscriptionId: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exposures?: ExposureUncheckedCreateNestedManyWithoutWatchlistItemInput
  }

  export type WatchlistItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutWatchlistItemsNestedInput
    exposures?: ExposureUpdateManyWithoutWatchlistItemNestedInput
  }

  export type WatchlistItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exposures?: ExposureUncheckedUpdateManyWithoutWatchlistItemNestedInput
  }

  export type WatchlistItemCreateManyInput = {
    id?: string
    subscriptionId: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WatchlistItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WatchlistItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExposureCreateInput = {
    id?: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutExposuresInput
    watchlistItem?: WatchlistItemCreateNestedOneWithoutExposuresInput
    alerts?: AlertCreateNestedManyWithoutExposureInput
  }

  export type ExposureUncheckedCreateInput = {
    id?: string
    subscriptionId: string
    watchlistItemId?: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    alerts?: AlertUncheckedCreateNestedManyWithoutExposureInput
  }

  export type ExposureUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutExposuresNestedInput
    watchlistItem?: WatchlistItemUpdateOneWithoutExposuresNestedInput
    alerts?: AlertUpdateManyWithoutExposureNestedInput
  }

  export type ExposureUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    watchlistItemId?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alerts?: AlertUncheckedUpdateManyWithoutExposureNestedInput
  }

  export type ExposureCreateManyInput = {
    id?: string
    subscriptionId: string
    watchlistItemId?: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExposureUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExposureUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    watchlistItemId?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertCreateInput = {
    id?: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutAlertsInput
    user: UserCreateNestedOneWithoutAlertsInput
    exposure?: ExposureCreateNestedOneWithoutAlertsInput
  }

  export type AlertUncheckedCreateInput = {
    id?: string
    subscriptionId: string
    userId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutAlertsNestedInput
    user?: UserUpdateOneRequiredWithoutAlertsNestedInput
    exposure?: ExposureUpdateOneWithoutAlertsNestedInput
  }

  export type AlertUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertCreateManyInput = {
    id?: string
    subscriptionId: string
    userId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceEnrollmentCreateInput = {
    id?: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutVoiceEnrollmentsInput
    analyses?: VoiceAnalysisCreateNestedManyWithoutEnrollmentInput
  }

  export type VoiceEnrollmentUncheckedCreateInput = {
    id?: string
    userId: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    analyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutEnrollmentInput
  }

  export type VoiceEnrollmentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutVoiceEnrollmentsNestedInput
    analyses?: VoiceAnalysisUpdateManyWithoutEnrollmentNestedInput
  }

  export type VoiceEnrollmentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: VoiceAnalysisUncheckedUpdateManyWithoutEnrollmentNestedInput
  }

  export type VoiceEnrollmentCreateManyInput = {
    id?: string
    userId: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VoiceEnrollmentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceEnrollmentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisCreateInput = {
    id?: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
    enrollment?: VoiceEnrollmentCreateNestedOneWithoutAnalysesInput
    user: UserCreateNestedOneWithoutVoiceAnalysesInput
  }

  export type VoiceAnalysisUncheckedCreateInput = {
    id?: string
    enrollmentId?: string | null
    userId: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type VoiceAnalysisUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    enrollment?: VoiceEnrollmentUpdateOneWithoutAnalysesNestedInput
    user?: UserUpdateOneRequiredWithoutVoiceAnalysesNestedInput
  }

  export type VoiceAnalysisUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    enrollmentId?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisCreateManyInput = {
    id?: string
    enrollmentId?: string | null
    userId: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type VoiceAnalysisUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    enrollmentId?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackCreateInput = {
    id?: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSpamFeedbackInput
  }

  export type SpamFeedbackUncheckedCreateInput = {
    id?: string
    userId: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamFeedbackUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSpamFeedbackNestedInput
  }

  export type SpamFeedbackUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackCreateManyInput = {
    id?: string
    userId: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamFeedbackUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleCreateInput = {
    id?: string
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user?: UserCreateNestedOneWithoutSpamRulesInput
  }

  export type SpamRuleUncheckedCreateInput = {
    id?: string
    userId?: string | null
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamRuleUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutSpamRulesNestedInput
  }

  export type SpamRuleUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleCreateManyInput = {
    id?: string
    userId?: string | null
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamRuleUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuditLogCreateInput = {
    id?: string
    userId?: string | null
    action: string
    resource: string
    resourceId?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
  }

  export type AuditLogUncheckedCreateInput = {
    id?: string
    userId?: string | null
    action: string
    resource: string
    resourceId?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
  }

  export type AuditLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resource?: StringFieldUpdateOperationsInput | string
    resourceId?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuditLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resource?: StringFieldUpdateOperationsInput | string
    resourceId?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuditLogCreateManyInput = {
    id?: string
    userId?: string | null
    action: string
    resource: string
    resourceId?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
  }

  export type AuditLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resource?: StringFieldUpdateOperationsInput | string
    resourceId?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuditLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resource?: StringFieldUpdateOperationsInput | string
    resourceId?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    metadata?: NullableJsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KPISnapshotCreateInput = {
    id?: string
    date: Date | string
    metricName: string
    metricValue: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
  }

  export type KPISnapshotUncheckedCreateInput = {
    id?: string
    date: Date | string
    metricName: string
    metricValue: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
  }

  export type KPISnapshotUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    metricName?: StringFieldUpdateOperationsInput | string
    metricValue?: FloatFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KPISnapshotUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    metricName?: StringFieldUpdateOperationsInput | string
    metricValue?: FloatFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KPISnapshotCreateManyInput = {
    id?: string
    date: Date | string
    metricName: string
    metricValue: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
  }

  export type KPISnapshotUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    metricName?: StringFieldUpdateOperationsInput | string
    metricValue?: FloatFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KPISnapshotUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    metricName?: StringFieldUpdateOperationsInput | string
    metricValue?: FloatFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  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 DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type EnumUserRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
  }

  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 AccountListRelationFilter = {
    every?: AccountWhereInput
    some?: AccountWhereInput
    none?: AccountWhereInput
  }

  export type SessionListRelationFilter = {
    every?: SessionWhereInput
    some?: SessionWhereInput
    none?: SessionWhereInput
  }

  export type FamilyGroupMemberListRelationFilter = {
    every?: FamilyGroupMemberWhereInput
    some?: FamilyGroupMemberWhereInput
    none?: FamilyGroupMemberWhereInput
  }

  export type FamilyGroupListRelationFilter = {
    every?: FamilyGroupWhereInput
    some?: FamilyGroupWhereInput
    none?: FamilyGroupWhereInput
  }

  export type SubscriptionListRelationFilter = {
    every?: SubscriptionWhereInput
    some?: SubscriptionWhereInput
    none?: SubscriptionWhereInput
  }

  export type AlertListRelationFilter = {
    every?: AlertWhereInput
    some?: AlertWhereInput
    none?: AlertWhereInput
  }

  export type VoiceEnrollmentListRelationFilter = {
    every?: VoiceEnrollmentWhereInput
    some?: VoiceEnrollmentWhereInput
    none?: VoiceEnrollmentWhereInput
  }

  export type VoiceAnalysisListRelationFilter = {
    every?: VoiceAnalysisWhereInput
    some?: VoiceAnalysisWhereInput
    none?: VoiceAnalysisWhereInput
  }

  export type SpamFeedbackListRelationFilter = {
    every?: SpamFeedbackWhereInput
    some?: SpamFeedbackWhereInput
    none?: SpamFeedbackWhereInput
  }

  export type SpamRuleListRelationFilter = {
    every?: SpamRuleWhereInput
    some?: SpamRuleWhereInput
    none?: SpamRuleWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AccountOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type FamilyGroupMemberOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type FamilyGroupOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SubscriptionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AlertOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type VoiceEnrollmentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type VoiceAnalysisOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SpamFeedbackOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SpamRuleOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    name?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    name?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    name?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type EnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumUserRoleFilter<$PrismaModel>
    _max?: NestedEnumUserRoleFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type 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 UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type AccountUserIdProviderProviderAccountIdCompoundUniqueInput = {
    userId: string
    provider: string
    providerAccountId: string
  }

  export type AccountCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    access_token?: SortOrder
    refresh_token?: SortOrder
    expires_at?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountAvgOrderByAggregateInput = {
    expires_at?: SortOrder
  }

  export type AccountMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    access_token?: SortOrder
    refresh_token?: SortOrder
    expires_at?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    access_token?: SortOrder
    refresh_token?: SortOrder
    expires_at?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountSumOrderByAggregateInput = {
    expires_at?: 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 SessionCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    sessionToken?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SessionMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    sessionToken?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SessionMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    sessionToken?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FamilyGroupCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    ownerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FamilyGroupMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    ownerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FamilyGroupMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    ownerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumFamilyMemberRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.FamilyMemberRole | EnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    in?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumFamilyMemberRoleFilter<$PrismaModel> | $Enums.FamilyMemberRole
  }

  export type FamilyGroupRelationFilter = {
    is?: FamilyGroupWhereInput
    isNot?: FamilyGroupWhereInput
  }

  export type FamilyGroupMemberGroupIdUserIdCompoundUniqueInput = {
    groupId: string
    userId: string
  }

  export type FamilyGroupMemberCountOrderByAggregateInput = {
    id?: SortOrder
    groupId?: SortOrder
    userId?: SortOrder
    role?: SortOrder
    joinedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FamilyGroupMemberMaxOrderByAggregateInput = {
    id?: SortOrder
    groupId?: SortOrder
    userId?: SortOrder
    role?: SortOrder
    joinedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FamilyGroupMemberMinOrderByAggregateInput = {
    id?: SortOrder
    groupId?: SortOrder
    userId?: SortOrder
    role?: SortOrder
    joinedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumFamilyMemberRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FamilyMemberRole | EnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    in?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumFamilyMemberRoleWithAggregatesFilter<$PrismaModel> | $Enums.FamilyMemberRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFamilyMemberRoleFilter<$PrismaModel>
    _max?: NestedEnumFamilyMemberRoleFilter<$PrismaModel>
  }

  export type EnumSubscriptionTierFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionTier | EnumSubscriptionTierFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionTierFilter<$PrismaModel> | $Enums.SubscriptionTier
  }

  export type EnumSubscriptionStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionStatus | EnumSubscriptionStatusFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionStatusFilter<$PrismaModel> | $Enums.SubscriptionStatus
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type FamilyGroupNullableRelationFilter = {
    is?: FamilyGroupWhereInput | null
    isNot?: FamilyGroupWhereInput | null
  }

  export type WatchlistItemListRelationFilter = {
    every?: WatchlistItemWhereInput
    some?: WatchlistItemWhereInput
    none?: WatchlistItemWhereInput
  }

  export type ExposureListRelationFilter = {
    every?: ExposureWhereInput
    some?: ExposureWhereInput
    none?: ExposureWhereInput
  }

  export type WatchlistItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ExposureOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SubscriptionCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    familyGroupId?: SortOrder
    stripeId?: SortOrder
    tier?: SortOrder
    status?: SortOrder
    currentPeriodStart?: SortOrder
    currentPeriodEnd?: SortOrder
    cancelAtPeriodEnd?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SubscriptionMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    familyGroupId?: SortOrder
    stripeId?: SortOrder
    tier?: SortOrder
    status?: SortOrder
    currentPeriodStart?: SortOrder
    currentPeriodEnd?: SortOrder
    cancelAtPeriodEnd?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SubscriptionMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    familyGroupId?: SortOrder
    stripeId?: SortOrder
    tier?: SortOrder
    status?: SortOrder
    currentPeriodStart?: SortOrder
    currentPeriodEnd?: SortOrder
    cancelAtPeriodEnd?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumSubscriptionTierWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionTier | EnumSubscriptionTierFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionTierWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionTier
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSubscriptionTierFilter<$PrismaModel>
    _max?: NestedEnumSubscriptionTierFilter<$PrismaModel>
  }

  export type EnumSubscriptionStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionStatus | EnumSubscriptionStatusFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionStatusWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSubscriptionStatusFilter<$PrismaModel>
    _max?: NestedEnumSubscriptionStatusFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type EnumWatchlistTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.WatchlistType | EnumWatchlistTypeFieldRefInput<$PrismaModel>
    in?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumWatchlistTypeFilter<$PrismaModel> | $Enums.WatchlistType
  }

  export type SubscriptionRelationFilter = {
    is?: SubscriptionWhereInput
    isNot?: SubscriptionWhereInput
  }

  export type WatchlistItemSubscriptionIdTypeHashCompoundUniqueInput = {
    subscriptionId: string
    type: $Enums.WatchlistType
    hash: string
  }

  export type WatchlistItemCountOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    hash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WatchlistItemMaxOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    hash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WatchlistItemMinOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    hash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumWatchlistTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.WatchlistType | EnumWatchlistTypeFieldRefInput<$PrismaModel>
    in?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumWatchlistTypeWithAggregatesFilter<$PrismaModel> | $Enums.WatchlistType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumWatchlistTypeFilter<$PrismaModel>
    _max?: NestedEnumWatchlistTypeFilter<$PrismaModel>
  }

  export type EnumExposureSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSource | EnumExposureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSourceFilter<$PrismaModel> | $Enums.ExposureSource
  }

  export type EnumExposureSeverityFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSeverity | EnumExposureSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSeverityFilter<$PrismaModel> | $Enums.ExposureSeverity
  }
  export type JsonNullableFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type WatchlistItemNullableRelationFilter = {
    is?: WatchlistItemWhereInput | null
    isNot?: WatchlistItemWhereInput | null
  }

  export type ExposureCountOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    watchlistItemId?: SortOrder
    source?: SortOrder
    dataType?: SortOrder
    identifier?: SortOrder
    identifierHash?: SortOrder
    severity?: SortOrder
    metadata?: SortOrder
    isFirstTime?: SortOrder
    detectedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ExposureMaxOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    watchlistItemId?: SortOrder
    source?: SortOrder
    dataType?: SortOrder
    identifier?: SortOrder
    identifierHash?: SortOrder
    severity?: SortOrder
    isFirstTime?: SortOrder
    detectedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ExposureMinOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    watchlistItemId?: SortOrder
    source?: SortOrder
    dataType?: SortOrder
    identifier?: SortOrder
    identifierHash?: SortOrder
    severity?: SortOrder
    isFirstTime?: SortOrder
    detectedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumExposureSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSource | EnumExposureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSourceWithAggregatesFilter<$PrismaModel> | $Enums.ExposureSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExposureSourceFilter<$PrismaModel>
    _max?: NestedEnumExposureSourceFilter<$PrismaModel>
  }

  export type EnumExposureSeverityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSeverity | EnumExposureSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSeverityWithAggregatesFilter<$PrismaModel> | $Enums.ExposureSeverity
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExposureSeverityFilter<$PrismaModel>
    _max?: NestedEnumExposureSeverityFilter<$PrismaModel>
  }
  export type JsonNullableWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type EnumAlertTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertType | EnumAlertTypeFieldRefInput<$PrismaModel>
    in?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertTypeFilter<$PrismaModel> | $Enums.AlertType
  }

  export type EnumAlertSeverityFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertSeverity | EnumAlertSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertSeverityFilter<$PrismaModel> | $Enums.AlertSeverity
  }

  export type EnumAlertChannelNullableListFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertChannel[] | ListEnumAlertChannelFieldRefInput<$PrismaModel> | null
    has?: $Enums.AlertChannel | EnumAlertChannelFieldRefInput<$PrismaModel> | null
    hasEvery?: $Enums.AlertChannel[] | ListEnumAlertChannelFieldRefInput<$PrismaModel>
    hasSome?: $Enums.AlertChannel[] | ListEnumAlertChannelFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }

  export type ExposureNullableRelationFilter = {
    is?: ExposureWhereInput | null
    isNot?: ExposureWhereInput | null
  }

  export type AlertCountOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    userId?: SortOrder
    exposureId?: SortOrder
    type?: SortOrder
    title?: SortOrder
    message?: SortOrder
    severity?: SortOrder
    isRead?: SortOrder
    readAt?: SortOrder
    channel?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AlertMaxOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    userId?: SortOrder
    exposureId?: SortOrder
    type?: SortOrder
    title?: SortOrder
    message?: SortOrder
    severity?: SortOrder
    isRead?: SortOrder
    readAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AlertMinOrderByAggregateInput = {
    id?: SortOrder
    subscriptionId?: SortOrder
    userId?: SortOrder
    exposureId?: SortOrder
    type?: SortOrder
    title?: SortOrder
    message?: SortOrder
    severity?: SortOrder
    isRead?: SortOrder
    readAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumAlertTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertType | EnumAlertTypeFieldRefInput<$PrismaModel>
    in?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertTypeWithAggregatesFilter<$PrismaModel> | $Enums.AlertType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAlertTypeFilter<$PrismaModel>
    _max?: NestedEnumAlertTypeFilter<$PrismaModel>
  }

  export type EnumAlertSeverityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertSeverity | EnumAlertSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertSeverityWithAggregatesFilter<$PrismaModel> | $Enums.AlertSeverity
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAlertSeverityFilter<$PrismaModel>
    _max?: NestedEnumAlertSeverityFilter<$PrismaModel>
  }

  export type VoiceEnrollmentCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    voiceHash?: SortOrder
    audioMetadata?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type VoiceEnrollmentMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    voiceHash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type VoiceEnrollmentMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    name?: SortOrder
    voiceHash?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FloatFilter<$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 JsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>

  export type JsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type VoiceEnrollmentNullableRelationFilter = {
    is?: VoiceEnrollmentWhereInput | null
    isNot?: VoiceEnrollmentWhereInput | null
  }

  export type VoiceAnalysisCountOrderByAggregateInput = {
    id?: SortOrder
    enrollmentId?: SortOrder
    userId?: SortOrder
    audioHash?: SortOrder
    isSynthetic?: SortOrder
    confidence?: SortOrder
    analysisResult?: SortOrder
    audioUrl?: SortOrder
    createdAt?: SortOrder
  }

  export type VoiceAnalysisAvgOrderByAggregateInput = {
    confidence?: SortOrder
  }

  export type VoiceAnalysisMaxOrderByAggregateInput = {
    id?: SortOrder
    enrollmentId?: SortOrder
    userId?: SortOrder
    audioHash?: SortOrder
    isSynthetic?: SortOrder
    confidence?: SortOrder
    audioUrl?: SortOrder
    createdAt?: SortOrder
  }

  export type VoiceAnalysisMinOrderByAggregateInput = {
    id?: SortOrder
    enrollmentId?: SortOrder
    userId?: SortOrder
    audioHash?: SortOrder
    isSynthetic?: SortOrder
    confidence?: SortOrder
    audioUrl?: SortOrder
    createdAt?: SortOrder
  }

  export type VoiceAnalysisSumOrderByAggregateInput = {
    confidence?: SortOrder
  }

  export type FloatWithAggregatesFilter<$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?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type FloatNullableFilter<$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 EnumFeedbackTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.FeedbackType | EnumFeedbackTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumFeedbackTypeFilter<$PrismaModel> | $Enums.FeedbackType
  }

  export type SpamFeedbackCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    phoneNumber?: SortOrder
    phoneNumberHash?: SortOrder
    isSpam?: SortOrder
    confidence?: SortOrder
    feedbackType?: SortOrder
    metadata?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamFeedbackAvgOrderByAggregateInput = {
    confidence?: SortOrder
  }

  export type SpamFeedbackMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    phoneNumber?: SortOrder
    phoneNumberHash?: SortOrder
    isSpam?: SortOrder
    confidence?: SortOrder
    feedbackType?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamFeedbackMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    phoneNumber?: SortOrder
    phoneNumberHash?: SortOrder
    isSpam?: SortOrder
    confidence?: SortOrder
    feedbackType?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamFeedbackSumOrderByAggregateInput = {
    confidence?: SortOrder
  }

  export type FloatNullableWithAggregatesFilter<$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?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type EnumFeedbackTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FeedbackType | EnumFeedbackTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumFeedbackTypeWithAggregatesFilter<$PrismaModel> | $Enums.FeedbackType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFeedbackTypeFilter<$PrismaModel>
    _max?: NestedEnumFeedbackTypeFilter<$PrismaModel>
  }

  export type EnumRuleTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleType | EnumRuleTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleTypeFilter<$PrismaModel> | $Enums.RuleType
  }

  export type EnumRuleActionFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleAction | EnumRuleActionFieldRefInput<$PrismaModel>
    in?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionFilter<$PrismaModel> | $Enums.RuleAction
  }

  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 UserNullableRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type SpamRuleCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    isGlobal?: SortOrder
    ruleType?: SortOrder
    pattern?: SortOrder
    action?: SortOrder
    priority?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamRuleAvgOrderByAggregateInput = {
    priority?: SortOrder
  }

  export type SpamRuleMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    isGlobal?: SortOrder
    ruleType?: SortOrder
    pattern?: SortOrder
    action?: SortOrder
    priority?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamRuleMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    isGlobal?: SortOrder
    ruleType?: SortOrder
    pattern?: SortOrder
    action?: SortOrder
    priority?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SpamRuleSumOrderByAggregateInput = {
    priority?: SortOrder
  }

  export type EnumRuleTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleType | EnumRuleTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleTypeFilter<$PrismaModel>
  }

  export type EnumRuleActionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleAction | EnumRuleActionFieldRefInput<$PrismaModel>
    in?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionWithAggregatesFilter<$PrismaModel> | $Enums.RuleAction
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleActionFilter<$PrismaModel>
    _max?: NestedEnumRuleActionFilter<$PrismaModel>
  }

  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 AuditLogCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    action?: SortOrder
    resource?: SortOrder
    resourceId?: SortOrder
    changes?: SortOrder
    metadata?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
  }

  export type AuditLogMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    action?: SortOrder
    resource?: SortOrder
    resourceId?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
  }

  export type AuditLogMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    action?: SortOrder
    resource?: SortOrder
    resourceId?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
  }

  export type KPISnapshotCountOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    metricName?: SortOrder
    metricValue?: SortOrder
    metadata?: SortOrder
    createdAt?: SortOrder
  }

  export type KPISnapshotAvgOrderByAggregateInput = {
    metricValue?: SortOrder
  }

  export type KPISnapshotMaxOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    metricName?: SortOrder
    metricValue?: SortOrder
    createdAt?: SortOrder
  }

  export type KPISnapshotMinOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    metricName?: SortOrder
    metricValue?: SortOrder
    createdAt?: SortOrder
  }

  export type KPISnapshotSumOrderByAggregateInput = {
    metricValue?: SortOrder
  }

  export type AccountCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type SessionCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type FamilyGroupMemberCreateNestedManyWithoutUserInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput> | FamilyGroupMemberCreateWithoutUserInput[] | FamilyGroupMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutUserInput | FamilyGroupMemberCreateOrConnectWithoutUserInput[]
    createMany?: FamilyGroupMemberCreateManyUserInputEnvelope
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
  }

  export type FamilyGroupCreateNestedManyWithoutOwnerInput = {
    create?: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput> | FamilyGroupCreateWithoutOwnerInput[] | FamilyGroupUncheckedCreateWithoutOwnerInput[]
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutOwnerInput | FamilyGroupCreateOrConnectWithoutOwnerInput[]
    createMany?: FamilyGroupCreateManyOwnerInputEnvelope
    connect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
  }

  export type SubscriptionCreateNestedManyWithoutUserInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type AlertCreateNestedManyWithoutUserInput = {
    create?: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput> | AlertCreateWithoutUserInput[] | AlertUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutUserInput | AlertCreateOrConnectWithoutUserInput[]
    createMany?: AlertCreateManyUserInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type VoiceEnrollmentCreateNestedManyWithoutUserInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput> | VoiceEnrollmentCreateWithoutUserInput[] | VoiceEnrollmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutUserInput | VoiceEnrollmentCreateOrConnectWithoutUserInput[]
    createMany?: VoiceEnrollmentCreateManyUserInputEnvelope
    connect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
  }

  export type VoiceAnalysisCreateNestedManyWithoutUserInput = {
    create?: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput> | VoiceAnalysisCreateWithoutUserInput[] | VoiceAnalysisUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutUserInput | VoiceAnalysisCreateOrConnectWithoutUserInput[]
    createMany?: VoiceAnalysisCreateManyUserInputEnvelope
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
  }

  export type SpamFeedbackCreateNestedManyWithoutUserInput = {
    create?: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput> | SpamFeedbackCreateWithoutUserInput[] | SpamFeedbackUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamFeedbackCreateOrConnectWithoutUserInput | SpamFeedbackCreateOrConnectWithoutUserInput[]
    createMany?: SpamFeedbackCreateManyUserInputEnvelope
    connect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
  }

  export type SpamRuleCreateNestedManyWithoutUserInput = {
    create?: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput> | SpamRuleCreateWithoutUserInput[] | SpamRuleUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamRuleCreateOrConnectWithoutUserInput | SpamRuleCreateOrConnectWithoutUserInput[]
    createMany?: SpamRuleCreateManyUserInputEnvelope
    connect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
  }

  export type AccountUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type SessionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput> | FamilyGroupMemberCreateWithoutUserInput[] | FamilyGroupMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutUserInput | FamilyGroupMemberCreateOrConnectWithoutUserInput[]
    createMany?: FamilyGroupMemberCreateManyUserInputEnvelope
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
  }

  export type FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput = {
    create?: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput> | FamilyGroupCreateWithoutOwnerInput[] | FamilyGroupUncheckedCreateWithoutOwnerInput[]
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutOwnerInput | FamilyGroupCreateOrConnectWithoutOwnerInput[]
    createMany?: FamilyGroupCreateManyOwnerInputEnvelope
    connect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
  }

  export type SubscriptionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type AlertUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput> | AlertCreateWithoutUserInput[] | AlertUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutUserInput | AlertCreateOrConnectWithoutUserInput[]
    createMany?: AlertCreateManyUserInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput> | VoiceEnrollmentCreateWithoutUserInput[] | VoiceEnrollmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutUserInput | VoiceEnrollmentCreateOrConnectWithoutUserInput[]
    createMany?: VoiceEnrollmentCreateManyUserInputEnvelope
    connect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
  }

  export type VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput> | VoiceAnalysisCreateWithoutUserInput[] | VoiceAnalysisUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutUserInput | VoiceAnalysisCreateOrConnectWithoutUserInput[]
    createMany?: VoiceAnalysisCreateManyUserInputEnvelope
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
  }

  export type SpamFeedbackUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput> | SpamFeedbackCreateWithoutUserInput[] | SpamFeedbackUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamFeedbackCreateOrConnectWithoutUserInput | SpamFeedbackCreateOrConnectWithoutUserInput[]
    createMany?: SpamFeedbackCreateManyUserInputEnvelope
    connect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
  }

  export type SpamRuleUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput> | SpamRuleCreateWithoutUserInput[] | SpamRuleUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamRuleCreateOrConnectWithoutUserInput | SpamRuleCreateOrConnectWithoutUserInput[]
    createMany?: SpamRuleCreateManyUserInputEnvelope
    connect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

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

  export type EnumUserRoleFieldUpdateOperationsInput = {
    set?: $Enums.UserRole
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type AccountUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type SessionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type FamilyGroupMemberUpdateManyWithoutUserNestedInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput> | FamilyGroupMemberCreateWithoutUserInput[] | FamilyGroupMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutUserInput | FamilyGroupMemberCreateOrConnectWithoutUserInput[]
    upsert?: FamilyGroupMemberUpsertWithWhereUniqueWithoutUserInput | FamilyGroupMemberUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: FamilyGroupMemberCreateManyUserInputEnvelope
    set?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    disconnect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    delete?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    update?: FamilyGroupMemberUpdateWithWhereUniqueWithoutUserInput | FamilyGroupMemberUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: FamilyGroupMemberUpdateManyWithWhereWithoutUserInput | FamilyGroupMemberUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
  }

  export type FamilyGroupUpdateManyWithoutOwnerNestedInput = {
    create?: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput> | FamilyGroupCreateWithoutOwnerInput[] | FamilyGroupUncheckedCreateWithoutOwnerInput[]
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutOwnerInput | FamilyGroupCreateOrConnectWithoutOwnerInput[]
    upsert?: FamilyGroupUpsertWithWhereUniqueWithoutOwnerInput | FamilyGroupUpsertWithWhereUniqueWithoutOwnerInput[]
    createMany?: FamilyGroupCreateManyOwnerInputEnvelope
    set?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    disconnect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    delete?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    connect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    update?: FamilyGroupUpdateWithWhereUniqueWithoutOwnerInput | FamilyGroupUpdateWithWhereUniqueWithoutOwnerInput[]
    updateMany?: FamilyGroupUpdateManyWithWhereWithoutOwnerInput | FamilyGroupUpdateManyWithWhereWithoutOwnerInput[]
    deleteMany?: FamilyGroupScalarWhereInput | FamilyGroupScalarWhereInput[]
  }

  export type SubscriptionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutUserInput | SubscriptionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutUserInput | SubscriptionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutUserInput | SubscriptionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type AlertUpdateManyWithoutUserNestedInput = {
    create?: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput> | AlertCreateWithoutUserInput[] | AlertUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutUserInput | AlertCreateOrConnectWithoutUserInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutUserInput | AlertUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AlertCreateManyUserInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutUserInput | AlertUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutUserInput | AlertUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type VoiceEnrollmentUpdateManyWithoutUserNestedInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput> | VoiceEnrollmentCreateWithoutUserInput[] | VoiceEnrollmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutUserInput | VoiceEnrollmentCreateOrConnectWithoutUserInput[]
    upsert?: VoiceEnrollmentUpsertWithWhereUniqueWithoutUserInput | VoiceEnrollmentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: VoiceEnrollmentCreateManyUserInputEnvelope
    set?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    disconnect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    delete?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    connect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    update?: VoiceEnrollmentUpdateWithWhereUniqueWithoutUserInput | VoiceEnrollmentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: VoiceEnrollmentUpdateManyWithWhereWithoutUserInput | VoiceEnrollmentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: VoiceEnrollmentScalarWhereInput | VoiceEnrollmentScalarWhereInput[]
  }

  export type VoiceAnalysisUpdateManyWithoutUserNestedInput = {
    create?: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput> | VoiceAnalysisCreateWithoutUserInput[] | VoiceAnalysisUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutUserInput | VoiceAnalysisCreateOrConnectWithoutUserInput[]
    upsert?: VoiceAnalysisUpsertWithWhereUniqueWithoutUserInput | VoiceAnalysisUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: VoiceAnalysisCreateManyUserInputEnvelope
    set?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    disconnect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    delete?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    update?: VoiceAnalysisUpdateWithWhereUniqueWithoutUserInput | VoiceAnalysisUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: VoiceAnalysisUpdateManyWithWhereWithoutUserInput | VoiceAnalysisUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
  }

  export type SpamFeedbackUpdateManyWithoutUserNestedInput = {
    create?: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput> | SpamFeedbackCreateWithoutUserInput[] | SpamFeedbackUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamFeedbackCreateOrConnectWithoutUserInput | SpamFeedbackCreateOrConnectWithoutUserInput[]
    upsert?: SpamFeedbackUpsertWithWhereUniqueWithoutUserInput | SpamFeedbackUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SpamFeedbackCreateManyUserInputEnvelope
    set?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    disconnect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    delete?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    connect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    update?: SpamFeedbackUpdateWithWhereUniqueWithoutUserInput | SpamFeedbackUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SpamFeedbackUpdateManyWithWhereWithoutUserInput | SpamFeedbackUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SpamFeedbackScalarWhereInput | SpamFeedbackScalarWhereInput[]
  }

  export type SpamRuleUpdateManyWithoutUserNestedInput = {
    create?: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput> | SpamRuleCreateWithoutUserInput[] | SpamRuleUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamRuleCreateOrConnectWithoutUserInput | SpamRuleCreateOrConnectWithoutUserInput[]
    upsert?: SpamRuleUpsertWithWhereUniqueWithoutUserInput | SpamRuleUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SpamRuleCreateManyUserInputEnvelope
    set?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    disconnect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    delete?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    connect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    update?: SpamRuleUpdateWithWhereUniqueWithoutUserInput | SpamRuleUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SpamRuleUpdateManyWithWhereWithoutUserInput | SpamRuleUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SpamRuleScalarWhereInput | SpamRuleScalarWhereInput[]
  }

  export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput> | FamilyGroupMemberCreateWithoutUserInput[] | FamilyGroupMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutUserInput | FamilyGroupMemberCreateOrConnectWithoutUserInput[]
    upsert?: FamilyGroupMemberUpsertWithWhereUniqueWithoutUserInput | FamilyGroupMemberUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: FamilyGroupMemberCreateManyUserInputEnvelope
    set?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    disconnect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    delete?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    update?: FamilyGroupMemberUpdateWithWhereUniqueWithoutUserInput | FamilyGroupMemberUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: FamilyGroupMemberUpdateManyWithWhereWithoutUserInput | FamilyGroupMemberUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
  }

  export type FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput = {
    create?: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput> | FamilyGroupCreateWithoutOwnerInput[] | FamilyGroupUncheckedCreateWithoutOwnerInput[]
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutOwnerInput | FamilyGroupCreateOrConnectWithoutOwnerInput[]
    upsert?: FamilyGroupUpsertWithWhereUniqueWithoutOwnerInput | FamilyGroupUpsertWithWhereUniqueWithoutOwnerInput[]
    createMany?: FamilyGroupCreateManyOwnerInputEnvelope
    set?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    disconnect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    delete?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    connect?: FamilyGroupWhereUniqueInput | FamilyGroupWhereUniqueInput[]
    update?: FamilyGroupUpdateWithWhereUniqueWithoutOwnerInput | FamilyGroupUpdateWithWhereUniqueWithoutOwnerInput[]
    updateMany?: FamilyGroupUpdateManyWithWhereWithoutOwnerInput | FamilyGroupUpdateManyWithWhereWithoutOwnerInput[]
    deleteMany?: FamilyGroupScalarWhereInput | FamilyGroupScalarWhereInput[]
  }

  export type SubscriptionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutUserInput | SubscriptionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutUserInput | SubscriptionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutUserInput | SubscriptionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type AlertUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput> | AlertCreateWithoutUserInput[] | AlertUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutUserInput | AlertCreateOrConnectWithoutUserInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutUserInput | AlertUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AlertCreateManyUserInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutUserInput | AlertUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutUserInput | AlertUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput> | VoiceEnrollmentCreateWithoutUserInput[] | VoiceEnrollmentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutUserInput | VoiceEnrollmentCreateOrConnectWithoutUserInput[]
    upsert?: VoiceEnrollmentUpsertWithWhereUniqueWithoutUserInput | VoiceEnrollmentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: VoiceEnrollmentCreateManyUserInputEnvelope
    set?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    disconnect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    delete?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    connect?: VoiceEnrollmentWhereUniqueInput | VoiceEnrollmentWhereUniqueInput[]
    update?: VoiceEnrollmentUpdateWithWhereUniqueWithoutUserInput | VoiceEnrollmentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: VoiceEnrollmentUpdateManyWithWhereWithoutUserInput | VoiceEnrollmentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: VoiceEnrollmentScalarWhereInput | VoiceEnrollmentScalarWhereInput[]
  }

  export type VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput> | VoiceAnalysisCreateWithoutUserInput[] | VoiceAnalysisUncheckedCreateWithoutUserInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutUserInput | VoiceAnalysisCreateOrConnectWithoutUserInput[]
    upsert?: VoiceAnalysisUpsertWithWhereUniqueWithoutUserInput | VoiceAnalysisUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: VoiceAnalysisCreateManyUserInputEnvelope
    set?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    disconnect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    delete?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    update?: VoiceAnalysisUpdateWithWhereUniqueWithoutUserInput | VoiceAnalysisUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: VoiceAnalysisUpdateManyWithWhereWithoutUserInput | VoiceAnalysisUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
  }

  export type SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput> | SpamFeedbackCreateWithoutUserInput[] | SpamFeedbackUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamFeedbackCreateOrConnectWithoutUserInput | SpamFeedbackCreateOrConnectWithoutUserInput[]
    upsert?: SpamFeedbackUpsertWithWhereUniqueWithoutUserInput | SpamFeedbackUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SpamFeedbackCreateManyUserInputEnvelope
    set?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    disconnect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    delete?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    connect?: SpamFeedbackWhereUniqueInput | SpamFeedbackWhereUniqueInput[]
    update?: SpamFeedbackUpdateWithWhereUniqueWithoutUserInput | SpamFeedbackUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SpamFeedbackUpdateManyWithWhereWithoutUserInput | SpamFeedbackUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SpamFeedbackScalarWhereInput | SpamFeedbackScalarWhereInput[]
  }

  export type SpamRuleUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput> | SpamRuleCreateWithoutUserInput[] | SpamRuleUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SpamRuleCreateOrConnectWithoutUserInput | SpamRuleCreateOrConnectWithoutUserInput[]
    upsert?: SpamRuleUpsertWithWhereUniqueWithoutUserInput | SpamRuleUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SpamRuleCreateManyUserInputEnvelope
    set?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    disconnect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    delete?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    connect?: SpamRuleWhereUniqueInput | SpamRuleWhereUniqueInput[]
    update?: SpamRuleUpdateWithWhereUniqueWithoutUserInput | SpamRuleUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SpamRuleUpdateManyWithWhereWithoutUserInput | SpamRuleUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SpamRuleScalarWhereInput | SpamRuleScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutAccountsInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    connect?: UserWhereUniqueInput
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserUpdateOneRequiredWithoutAccountsNestedInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    upsert?: UserUpsertWithoutAccountsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccountsInput, UserUpdateWithoutAccountsInput>, UserUncheckedUpdateWithoutAccountsInput>
  }

  export type UserCreateNestedOneWithoutSessionsInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    upsert?: UserUpsertWithoutSessionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionsInput, UserUpdateWithoutSessionsInput>, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserCreateNestedOneWithoutFamilyGroupOwnedInput = {
    create?: XOR<UserCreateWithoutFamilyGroupOwnedInput, UserUncheckedCreateWithoutFamilyGroupOwnedInput>
    connectOrCreate?: UserCreateOrConnectWithoutFamilyGroupOwnedInput
    connect?: UserWhereUniqueInput
  }

  export type FamilyGroupMemberCreateNestedManyWithoutGroupInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput> | FamilyGroupMemberCreateWithoutGroupInput[] | FamilyGroupMemberUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutGroupInput | FamilyGroupMemberCreateOrConnectWithoutGroupInput[]
    createMany?: FamilyGroupMemberCreateManyGroupInputEnvelope
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
  }

  export type SubscriptionCreateNestedManyWithoutFamilyGroupInput = {
    create?: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput> | SubscriptionCreateWithoutFamilyGroupInput[] | SubscriptionUncheckedCreateWithoutFamilyGroupInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutFamilyGroupInput | SubscriptionCreateOrConnectWithoutFamilyGroupInput[]
    createMany?: SubscriptionCreateManyFamilyGroupInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type FamilyGroupMemberUncheckedCreateNestedManyWithoutGroupInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput> | FamilyGroupMemberCreateWithoutGroupInput[] | FamilyGroupMemberUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutGroupInput | FamilyGroupMemberCreateOrConnectWithoutGroupInput[]
    createMany?: FamilyGroupMemberCreateManyGroupInputEnvelope
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
  }

  export type SubscriptionUncheckedCreateNestedManyWithoutFamilyGroupInput = {
    create?: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput> | SubscriptionCreateWithoutFamilyGroupInput[] | SubscriptionUncheckedCreateWithoutFamilyGroupInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutFamilyGroupInput | SubscriptionCreateOrConnectWithoutFamilyGroupInput[]
    createMany?: SubscriptionCreateManyFamilyGroupInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutFamilyGroupOwnedNestedInput = {
    create?: XOR<UserCreateWithoutFamilyGroupOwnedInput, UserUncheckedCreateWithoutFamilyGroupOwnedInput>
    connectOrCreate?: UserCreateOrConnectWithoutFamilyGroupOwnedInput
    upsert?: UserUpsertWithoutFamilyGroupOwnedInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutFamilyGroupOwnedInput, UserUpdateWithoutFamilyGroupOwnedInput>, UserUncheckedUpdateWithoutFamilyGroupOwnedInput>
  }

  export type FamilyGroupMemberUpdateManyWithoutGroupNestedInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput> | FamilyGroupMemberCreateWithoutGroupInput[] | FamilyGroupMemberUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutGroupInput | FamilyGroupMemberCreateOrConnectWithoutGroupInput[]
    upsert?: FamilyGroupMemberUpsertWithWhereUniqueWithoutGroupInput | FamilyGroupMemberUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: FamilyGroupMemberCreateManyGroupInputEnvelope
    set?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    disconnect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    delete?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    update?: FamilyGroupMemberUpdateWithWhereUniqueWithoutGroupInput | FamilyGroupMemberUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: FamilyGroupMemberUpdateManyWithWhereWithoutGroupInput | FamilyGroupMemberUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
  }

  export type SubscriptionUpdateManyWithoutFamilyGroupNestedInput = {
    create?: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput> | SubscriptionCreateWithoutFamilyGroupInput[] | SubscriptionUncheckedCreateWithoutFamilyGroupInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutFamilyGroupInput | SubscriptionCreateOrConnectWithoutFamilyGroupInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutFamilyGroupInput | SubscriptionUpsertWithWhereUniqueWithoutFamilyGroupInput[]
    createMany?: SubscriptionCreateManyFamilyGroupInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutFamilyGroupInput | SubscriptionUpdateWithWhereUniqueWithoutFamilyGroupInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutFamilyGroupInput | SubscriptionUpdateManyWithWhereWithoutFamilyGroupInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type FamilyGroupMemberUncheckedUpdateManyWithoutGroupNestedInput = {
    create?: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput> | FamilyGroupMemberCreateWithoutGroupInput[] | FamilyGroupMemberUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: FamilyGroupMemberCreateOrConnectWithoutGroupInput | FamilyGroupMemberCreateOrConnectWithoutGroupInput[]
    upsert?: FamilyGroupMemberUpsertWithWhereUniqueWithoutGroupInput | FamilyGroupMemberUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: FamilyGroupMemberCreateManyGroupInputEnvelope
    set?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    disconnect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    delete?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    connect?: FamilyGroupMemberWhereUniqueInput | FamilyGroupMemberWhereUniqueInput[]
    update?: FamilyGroupMemberUpdateWithWhereUniqueWithoutGroupInput | FamilyGroupMemberUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: FamilyGroupMemberUpdateManyWithWhereWithoutGroupInput | FamilyGroupMemberUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
  }

  export type SubscriptionUncheckedUpdateManyWithoutFamilyGroupNestedInput = {
    create?: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput> | SubscriptionCreateWithoutFamilyGroupInput[] | SubscriptionUncheckedCreateWithoutFamilyGroupInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutFamilyGroupInput | SubscriptionCreateOrConnectWithoutFamilyGroupInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutFamilyGroupInput | SubscriptionUpsertWithWhereUniqueWithoutFamilyGroupInput[]
    createMany?: SubscriptionCreateManyFamilyGroupInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutFamilyGroupInput | SubscriptionUpdateWithWhereUniqueWithoutFamilyGroupInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutFamilyGroupInput | SubscriptionUpdateManyWithWhereWithoutFamilyGroupInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type FamilyGroupCreateNestedOneWithoutMembersInput = {
    create?: XOR<FamilyGroupCreateWithoutMembersInput, FamilyGroupUncheckedCreateWithoutMembersInput>
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutMembersInput
    connect?: FamilyGroupWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutFamilyGroupsInput = {
    create?: XOR<UserCreateWithoutFamilyGroupsInput, UserUncheckedCreateWithoutFamilyGroupsInput>
    connectOrCreate?: UserCreateOrConnectWithoutFamilyGroupsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumFamilyMemberRoleFieldUpdateOperationsInput = {
    set?: $Enums.FamilyMemberRole
  }

  export type FamilyGroupUpdateOneRequiredWithoutMembersNestedInput = {
    create?: XOR<FamilyGroupCreateWithoutMembersInput, FamilyGroupUncheckedCreateWithoutMembersInput>
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutMembersInput
    upsert?: FamilyGroupUpsertWithoutMembersInput
    connect?: FamilyGroupWhereUniqueInput
    update?: XOR<XOR<FamilyGroupUpdateToOneWithWhereWithoutMembersInput, FamilyGroupUpdateWithoutMembersInput>, FamilyGroupUncheckedUpdateWithoutMembersInput>
  }

  export type UserUpdateOneRequiredWithoutFamilyGroupsNestedInput = {
    create?: XOR<UserCreateWithoutFamilyGroupsInput, UserUncheckedCreateWithoutFamilyGroupsInput>
    connectOrCreate?: UserCreateOrConnectWithoutFamilyGroupsInput
    upsert?: UserUpsertWithoutFamilyGroupsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutFamilyGroupsInput, UserUpdateWithoutFamilyGroupsInput>, UserUncheckedUpdateWithoutFamilyGroupsInput>
  }

  export type UserCreateNestedOneWithoutSubscriptionsInput = {
    create?: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSubscriptionsInput
    connect?: UserWhereUniqueInput
  }

  export type FamilyGroupCreateNestedOneWithoutSubscriptionsInput = {
    create?: XOR<FamilyGroupCreateWithoutSubscriptionsInput, FamilyGroupUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutSubscriptionsInput
    connect?: FamilyGroupWhereUniqueInput
  }

  export type WatchlistItemCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput> | WatchlistItemCreateWithoutSubscriptionInput[] | WatchlistItemUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutSubscriptionInput | WatchlistItemCreateOrConnectWithoutSubscriptionInput[]
    createMany?: WatchlistItemCreateManySubscriptionInputEnvelope
    connect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
  }

  export type ExposureCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput> | ExposureCreateWithoutSubscriptionInput[] | ExposureUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutSubscriptionInput | ExposureCreateOrConnectWithoutSubscriptionInput[]
    createMany?: ExposureCreateManySubscriptionInputEnvelope
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
  }

  export type AlertCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput> | AlertCreateWithoutSubscriptionInput[] | AlertUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutSubscriptionInput | AlertCreateOrConnectWithoutSubscriptionInput[]
    createMany?: AlertCreateManySubscriptionInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput> | WatchlistItemCreateWithoutSubscriptionInput[] | WatchlistItemUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutSubscriptionInput | WatchlistItemCreateOrConnectWithoutSubscriptionInput[]
    createMany?: WatchlistItemCreateManySubscriptionInputEnvelope
    connect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
  }

  export type ExposureUncheckedCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput> | ExposureCreateWithoutSubscriptionInput[] | ExposureUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutSubscriptionInput | ExposureCreateOrConnectWithoutSubscriptionInput[]
    createMany?: ExposureCreateManySubscriptionInputEnvelope
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
  }

  export type AlertUncheckedCreateNestedManyWithoutSubscriptionInput = {
    create?: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput> | AlertCreateWithoutSubscriptionInput[] | AlertUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutSubscriptionInput | AlertCreateOrConnectWithoutSubscriptionInput[]
    createMany?: AlertCreateManySubscriptionInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type EnumSubscriptionTierFieldUpdateOperationsInput = {
    set?: $Enums.SubscriptionTier
  }

  export type EnumSubscriptionStatusFieldUpdateOperationsInput = {
    set?: $Enums.SubscriptionStatus
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type UserUpdateOneRequiredWithoutSubscriptionsNestedInput = {
    create?: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSubscriptionsInput
    upsert?: UserUpsertWithoutSubscriptionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSubscriptionsInput, UserUpdateWithoutSubscriptionsInput>, UserUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type FamilyGroupUpdateOneWithoutSubscriptionsNestedInput = {
    create?: XOR<FamilyGroupCreateWithoutSubscriptionsInput, FamilyGroupUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: FamilyGroupCreateOrConnectWithoutSubscriptionsInput
    upsert?: FamilyGroupUpsertWithoutSubscriptionsInput
    disconnect?: FamilyGroupWhereInput | boolean
    delete?: FamilyGroupWhereInput | boolean
    connect?: FamilyGroupWhereUniqueInput
    update?: XOR<XOR<FamilyGroupUpdateToOneWithWhereWithoutSubscriptionsInput, FamilyGroupUpdateWithoutSubscriptionsInput>, FamilyGroupUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type WatchlistItemUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput> | WatchlistItemCreateWithoutSubscriptionInput[] | WatchlistItemUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutSubscriptionInput | WatchlistItemCreateOrConnectWithoutSubscriptionInput[]
    upsert?: WatchlistItemUpsertWithWhereUniqueWithoutSubscriptionInput | WatchlistItemUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: WatchlistItemCreateManySubscriptionInputEnvelope
    set?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    disconnect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    delete?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    connect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    update?: WatchlistItemUpdateWithWhereUniqueWithoutSubscriptionInput | WatchlistItemUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: WatchlistItemUpdateManyWithWhereWithoutSubscriptionInput | WatchlistItemUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: WatchlistItemScalarWhereInput | WatchlistItemScalarWhereInput[]
  }

  export type ExposureUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput> | ExposureCreateWithoutSubscriptionInput[] | ExposureUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutSubscriptionInput | ExposureCreateOrConnectWithoutSubscriptionInput[]
    upsert?: ExposureUpsertWithWhereUniqueWithoutSubscriptionInput | ExposureUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: ExposureCreateManySubscriptionInputEnvelope
    set?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    disconnect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    delete?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    update?: ExposureUpdateWithWhereUniqueWithoutSubscriptionInput | ExposureUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: ExposureUpdateManyWithWhereWithoutSubscriptionInput | ExposureUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
  }

  export type AlertUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput> | AlertCreateWithoutSubscriptionInput[] | AlertUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutSubscriptionInput | AlertCreateOrConnectWithoutSubscriptionInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutSubscriptionInput | AlertUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: AlertCreateManySubscriptionInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutSubscriptionInput | AlertUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutSubscriptionInput | AlertUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput> | WatchlistItemCreateWithoutSubscriptionInput[] | WatchlistItemUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutSubscriptionInput | WatchlistItemCreateOrConnectWithoutSubscriptionInput[]
    upsert?: WatchlistItemUpsertWithWhereUniqueWithoutSubscriptionInput | WatchlistItemUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: WatchlistItemCreateManySubscriptionInputEnvelope
    set?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    disconnect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    delete?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    connect?: WatchlistItemWhereUniqueInput | WatchlistItemWhereUniqueInput[]
    update?: WatchlistItemUpdateWithWhereUniqueWithoutSubscriptionInput | WatchlistItemUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: WatchlistItemUpdateManyWithWhereWithoutSubscriptionInput | WatchlistItemUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: WatchlistItemScalarWhereInput | WatchlistItemScalarWhereInput[]
  }

  export type ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput> | ExposureCreateWithoutSubscriptionInput[] | ExposureUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutSubscriptionInput | ExposureCreateOrConnectWithoutSubscriptionInput[]
    upsert?: ExposureUpsertWithWhereUniqueWithoutSubscriptionInput | ExposureUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: ExposureCreateManySubscriptionInputEnvelope
    set?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    disconnect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    delete?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    update?: ExposureUpdateWithWhereUniqueWithoutSubscriptionInput | ExposureUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: ExposureUpdateManyWithWhereWithoutSubscriptionInput | ExposureUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
  }

  export type AlertUncheckedUpdateManyWithoutSubscriptionNestedInput = {
    create?: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput> | AlertCreateWithoutSubscriptionInput[] | AlertUncheckedCreateWithoutSubscriptionInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutSubscriptionInput | AlertCreateOrConnectWithoutSubscriptionInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutSubscriptionInput | AlertUpsertWithWhereUniqueWithoutSubscriptionInput[]
    createMany?: AlertCreateManySubscriptionInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutSubscriptionInput | AlertUpdateWithWhereUniqueWithoutSubscriptionInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutSubscriptionInput | AlertUpdateManyWithWhereWithoutSubscriptionInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type SubscriptionCreateNestedOneWithoutWatchlistItemsInput = {
    create?: XOR<SubscriptionCreateWithoutWatchlistItemsInput, SubscriptionUncheckedCreateWithoutWatchlistItemsInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutWatchlistItemsInput
    connect?: SubscriptionWhereUniqueInput
  }

  export type ExposureCreateNestedManyWithoutWatchlistItemInput = {
    create?: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput> | ExposureCreateWithoutWatchlistItemInput[] | ExposureUncheckedCreateWithoutWatchlistItemInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutWatchlistItemInput | ExposureCreateOrConnectWithoutWatchlistItemInput[]
    createMany?: ExposureCreateManyWatchlistItemInputEnvelope
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
  }

  export type ExposureUncheckedCreateNestedManyWithoutWatchlistItemInput = {
    create?: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput> | ExposureCreateWithoutWatchlistItemInput[] | ExposureUncheckedCreateWithoutWatchlistItemInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutWatchlistItemInput | ExposureCreateOrConnectWithoutWatchlistItemInput[]
    createMany?: ExposureCreateManyWatchlistItemInputEnvelope
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
  }

  export type EnumWatchlistTypeFieldUpdateOperationsInput = {
    set?: $Enums.WatchlistType
  }

  export type SubscriptionUpdateOneRequiredWithoutWatchlistItemsNestedInput = {
    create?: XOR<SubscriptionCreateWithoutWatchlistItemsInput, SubscriptionUncheckedCreateWithoutWatchlistItemsInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutWatchlistItemsInput
    upsert?: SubscriptionUpsertWithoutWatchlistItemsInput
    connect?: SubscriptionWhereUniqueInput
    update?: XOR<XOR<SubscriptionUpdateToOneWithWhereWithoutWatchlistItemsInput, SubscriptionUpdateWithoutWatchlistItemsInput>, SubscriptionUncheckedUpdateWithoutWatchlistItemsInput>
  }

  export type ExposureUpdateManyWithoutWatchlistItemNestedInput = {
    create?: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput> | ExposureCreateWithoutWatchlistItemInput[] | ExposureUncheckedCreateWithoutWatchlistItemInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutWatchlistItemInput | ExposureCreateOrConnectWithoutWatchlistItemInput[]
    upsert?: ExposureUpsertWithWhereUniqueWithoutWatchlistItemInput | ExposureUpsertWithWhereUniqueWithoutWatchlistItemInput[]
    createMany?: ExposureCreateManyWatchlistItemInputEnvelope
    set?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    disconnect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    delete?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    update?: ExposureUpdateWithWhereUniqueWithoutWatchlistItemInput | ExposureUpdateWithWhereUniqueWithoutWatchlistItemInput[]
    updateMany?: ExposureUpdateManyWithWhereWithoutWatchlistItemInput | ExposureUpdateManyWithWhereWithoutWatchlistItemInput[]
    deleteMany?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
  }

  export type ExposureUncheckedUpdateManyWithoutWatchlistItemNestedInput = {
    create?: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput> | ExposureCreateWithoutWatchlistItemInput[] | ExposureUncheckedCreateWithoutWatchlistItemInput[]
    connectOrCreate?: ExposureCreateOrConnectWithoutWatchlistItemInput | ExposureCreateOrConnectWithoutWatchlistItemInput[]
    upsert?: ExposureUpsertWithWhereUniqueWithoutWatchlistItemInput | ExposureUpsertWithWhereUniqueWithoutWatchlistItemInput[]
    createMany?: ExposureCreateManyWatchlistItemInputEnvelope
    set?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    disconnect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    delete?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    connect?: ExposureWhereUniqueInput | ExposureWhereUniqueInput[]
    update?: ExposureUpdateWithWhereUniqueWithoutWatchlistItemInput | ExposureUpdateWithWhereUniqueWithoutWatchlistItemInput[]
    updateMany?: ExposureUpdateManyWithWhereWithoutWatchlistItemInput | ExposureUpdateManyWithWhereWithoutWatchlistItemInput[]
    deleteMany?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
  }

  export type SubscriptionCreateNestedOneWithoutExposuresInput = {
    create?: XOR<SubscriptionCreateWithoutExposuresInput, SubscriptionUncheckedCreateWithoutExposuresInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutExposuresInput
    connect?: SubscriptionWhereUniqueInput
  }

  export type WatchlistItemCreateNestedOneWithoutExposuresInput = {
    create?: XOR<WatchlistItemCreateWithoutExposuresInput, WatchlistItemUncheckedCreateWithoutExposuresInput>
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutExposuresInput
    connect?: WatchlistItemWhereUniqueInput
  }

  export type AlertCreateNestedManyWithoutExposureInput = {
    create?: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput> | AlertCreateWithoutExposureInput[] | AlertUncheckedCreateWithoutExposureInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutExposureInput | AlertCreateOrConnectWithoutExposureInput[]
    createMany?: AlertCreateManyExposureInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type AlertUncheckedCreateNestedManyWithoutExposureInput = {
    create?: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput> | AlertCreateWithoutExposureInput[] | AlertUncheckedCreateWithoutExposureInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutExposureInput | AlertCreateOrConnectWithoutExposureInput[]
    createMany?: AlertCreateManyExposureInputEnvelope
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
  }

  export type EnumExposureSourceFieldUpdateOperationsInput = {
    set?: $Enums.ExposureSource
  }

  export type EnumExposureSeverityFieldUpdateOperationsInput = {
    set?: $Enums.ExposureSeverity
  }

  export type SubscriptionUpdateOneRequiredWithoutExposuresNestedInput = {
    create?: XOR<SubscriptionCreateWithoutExposuresInput, SubscriptionUncheckedCreateWithoutExposuresInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutExposuresInput
    upsert?: SubscriptionUpsertWithoutExposuresInput
    connect?: SubscriptionWhereUniqueInput
    update?: XOR<XOR<SubscriptionUpdateToOneWithWhereWithoutExposuresInput, SubscriptionUpdateWithoutExposuresInput>, SubscriptionUncheckedUpdateWithoutExposuresInput>
  }

  export type WatchlistItemUpdateOneWithoutExposuresNestedInput = {
    create?: XOR<WatchlistItemCreateWithoutExposuresInput, WatchlistItemUncheckedCreateWithoutExposuresInput>
    connectOrCreate?: WatchlistItemCreateOrConnectWithoutExposuresInput
    upsert?: WatchlistItemUpsertWithoutExposuresInput
    disconnect?: WatchlistItemWhereInput | boolean
    delete?: WatchlistItemWhereInput | boolean
    connect?: WatchlistItemWhereUniqueInput
    update?: XOR<XOR<WatchlistItemUpdateToOneWithWhereWithoutExposuresInput, WatchlistItemUpdateWithoutExposuresInput>, WatchlistItemUncheckedUpdateWithoutExposuresInput>
  }

  export type AlertUpdateManyWithoutExposureNestedInput = {
    create?: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput> | AlertCreateWithoutExposureInput[] | AlertUncheckedCreateWithoutExposureInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutExposureInput | AlertCreateOrConnectWithoutExposureInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutExposureInput | AlertUpsertWithWhereUniqueWithoutExposureInput[]
    createMany?: AlertCreateManyExposureInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutExposureInput | AlertUpdateWithWhereUniqueWithoutExposureInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutExposureInput | AlertUpdateManyWithWhereWithoutExposureInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type AlertUncheckedUpdateManyWithoutExposureNestedInput = {
    create?: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput> | AlertCreateWithoutExposureInput[] | AlertUncheckedCreateWithoutExposureInput[]
    connectOrCreate?: AlertCreateOrConnectWithoutExposureInput | AlertCreateOrConnectWithoutExposureInput[]
    upsert?: AlertUpsertWithWhereUniqueWithoutExposureInput | AlertUpsertWithWhereUniqueWithoutExposureInput[]
    createMany?: AlertCreateManyExposureInputEnvelope
    set?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    disconnect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    delete?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    connect?: AlertWhereUniqueInput | AlertWhereUniqueInput[]
    update?: AlertUpdateWithWhereUniqueWithoutExposureInput | AlertUpdateWithWhereUniqueWithoutExposureInput[]
    updateMany?: AlertUpdateManyWithWhereWithoutExposureInput | AlertUpdateManyWithWhereWithoutExposureInput[]
    deleteMany?: AlertScalarWhereInput | AlertScalarWhereInput[]
  }

  export type AlertCreatechannelInput = {
    set: $Enums.AlertChannel[]
  }

  export type SubscriptionCreateNestedOneWithoutAlertsInput = {
    create?: XOR<SubscriptionCreateWithoutAlertsInput, SubscriptionUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutAlertsInput
    connect?: SubscriptionWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutAlertsInput = {
    create?: XOR<UserCreateWithoutAlertsInput, UserUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAlertsInput
    connect?: UserWhereUniqueInput
  }

  export type ExposureCreateNestedOneWithoutAlertsInput = {
    create?: XOR<ExposureCreateWithoutAlertsInput, ExposureUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: ExposureCreateOrConnectWithoutAlertsInput
    connect?: ExposureWhereUniqueInput
  }

  export type EnumAlertTypeFieldUpdateOperationsInput = {
    set?: $Enums.AlertType
  }

  export type EnumAlertSeverityFieldUpdateOperationsInput = {
    set?: $Enums.AlertSeverity
  }

  export type AlertUpdatechannelInput = {
    set?: $Enums.AlertChannel[]
    push?: $Enums.AlertChannel | $Enums.AlertChannel[]
  }

  export type SubscriptionUpdateOneRequiredWithoutAlertsNestedInput = {
    create?: XOR<SubscriptionCreateWithoutAlertsInput, SubscriptionUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: SubscriptionCreateOrConnectWithoutAlertsInput
    upsert?: SubscriptionUpsertWithoutAlertsInput
    connect?: SubscriptionWhereUniqueInput
    update?: XOR<XOR<SubscriptionUpdateToOneWithWhereWithoutAlertsInput, SubscriptionUpdateWithoutAlertsInput>, SubscriptionUncheckedUpdateWithoutAlertsInput>
  }

  export type UserUpdateOneRequiredWithoutAlertsNestedInput = {
    create?: XOR<UserCreateWithoutAlertsInput, UserUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAlertsInput
    upsert?: UserUpsertWithoutAlertsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAlertsInput, UserUpdateWithoutAlertsInput>, UserUncheckedUpdateWithoutAlertsInput>
  }

  export type ExposureUpdateOneWithoutAlertsNestedInput = {
    create?: XOR<ExposureCreateWithoutAlertsInput, ExposureUncheckedCreateWithoutAlertsInput>
    connectOrCreate?: ExposureCreateOrConnectWithoutAlertsInput
    upsert?: ExposureUpsertWithoutAlertsInput
    disconnect?: ExposureWhereInput | boolean
    delete?: ExposureWhereInput | boolean
    connect?: ExposureWhereUniqueInput
    update?: XOR<XOR<ExposureUpdateToOneWithWhereWithoutAlertsInput, ExposureUpdateWithoutAlertsInput>, ExposureUncheckedUpdateWithoutAlertsInput>
  }

  export type UserCreateNestedOneWithoutVoiceEnrollmentsInput = {
    create?: XOR<UserCreateWithoutVoiceEnrollmentsInput, UserUncheckedCreateWithoutVoiceEnrollmentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutVoiceEnrollmentsInput
    connect?: UserWhereUniqueInput
  }

  export type VoiceAnalysisCreateNestedManyWithoutEnrollmentInput = {
    create?: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput> | VoiceAnalysisCreateWithoutEnrollmentInput[] | VoiceAnalysisUncheckedCreateWithoutEnrollmentInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutEnrollmentInput | VoiceAnalysisCreateOrConnectWithoutEnrollmentInput[]
    createMany?: VoiceAnalysisCreateManyEnrollmentInputEnvelope
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
  }

  export type VoiceAnalysisUncheckedCreateNestedManyWithoutEnrollmentInput = {
    create?: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput> | VoiceAnalysisCreateWithoutEnrollmentInput[] | VoiceAnalysisUncheckedCreateWithoutEnrollmentInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutEnrollmentInput | VoiceAnalysisCreateOrConnectWithoutEnrollmentInput[]
    createMany?: VoiceAnalysisCreateManyEnrollmentInputEnvelope
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
  }

  export type UserUpdateOneRequiredWithoutVoiceEnrollmentsNestedInput = {
    create?: XOR<UserCreateWithoutVoiceEnrollmentsInput, UserUncheckedCreateWithoutVoiceEnrollmentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutVoiceEnrollmentsInput
    upsert?: UserUpsertWithoutVoiceEnrollmentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutVoiceEnrollmentsInput, UserUpdateWithoutVoiceEnrollmentsInput>, UserUncheckedUpdateWithoutVoiceEnrollmentsInput>
  }

  export type VoiceAnalysisUpdateManyWithoutEnrollmentNestedInput = {
    create?: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput> | VoiceAnalysisCreateWithoutEnrollmentInput[] | VoiceAnalysisUncheckedCreateWithoutEnrollmentInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutEnrollmentInput | VoiceAnalysisCreateOrConnectWithoutEnrollmentInput[]
    upsert?: VoiceAnalysisUpsertWithWhereUniqueWithoutEnrollmentInput | VoiceAnalysisUpsertWithWhereUniqueWithoutEnrollmentInput[]
    createMany?: VoiceAnalysisCreateManyEnrollmentInputEnvelope
    set?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    disconnect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    delete?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    update?: VoiceAnalysisUpdateWithWhereUniqueWithoutEnrollmentInput | VoiceAnalysisUpdateWithWhereUniqueWithoutEnrollmentInput[]
    updateMany?: VoiceAnalysisUpdateManyWithWhereWithoutEnrollmentInput | VoiceAnalysisUpdateManyWithWhereWithoutEnrollmentInput[]
    deleteMany?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
  }

  export type VoiceAnalysisUncheckedUpdateManyWithoutEnrollmentNestedInput = {
    create?: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput> | VoiceAnalysisCreateWithoutEnrollmentInput[] | VoiceAnalysisUncheckedCreateWithoutEnrollmentInput[]
    connectOrCreate?: VoiceAnalysisCreateOrConnectWithoutEnrollmentInput | VoiceAnalysisCreateOrConnectWithoutEnrollmentInput[]
    upsert?: VoiceAnalysisUpsertWithWhereUniqueWithoutEnrollmentInput | VoiceAnalysisUpsertWithWhereUniqueWithoutEnrollmentInput[]
    createMany?: VoiceAnalysisCreateManyEnrollmentInputEnvelope
    set?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    disconnect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    delete?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    connect?: VoiceAnalysisWhereUniqueInput | VoiceAnalysisWhereUniqueInput[]
    update?: VoiceAnalysisUpdateWithWhereUniqueWithoutEnrollmentInput | VoiceAnalysisUpdateWithWhereUniqueWithoutEnrollmentInput[]
    updateMany?: VoiceAnalysisUpdateManyWithWhereWithoutEnrollmentInput | VoiceAnalysisUpdateManyWithWhereWithoutEnrollmentInput[]
    deleteMany?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
  }

  export type VoiceEnrollmentCreateNestedOneWithoutAnalysesInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutAnalysesInput, VoiceEnrollmentUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutAnalysesInput
    connect?: VoiceEnrollmentWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutVoiceAnalysesInput = {
    create?: XOR<UserCreateWithoutVoiceAnalysesInput, UserUncheckedCreateWithoutVoiceAnalysesInput>
    connectOrCreate?: UserCreateOrConnectWithoutVoiceAnalysesInput
    connect?: UserWhereUniqueInput
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type VoiceEnrollmentUpdateOneWithoutAnalysesNestedInput = {
    create?: XOR<VoiceEnrollmentCreateWithoutAnalysesInput, VoiceEnrollmentUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: VoiceEnrollmentCreateOrConnectWithoutAnalysesInput
    upsert?: VoiceEnrollmentUpsertWithoutAnalysesInput
    disconnect?: VoiceEnrollmentWhereInput | boolean
    delete?: VoiceEnrollmentWhereInput | boolean
    connect?: VoiceEnrollmentWhereUniqueInput
    update?: XOR<XOR<VoiceEnrollmentUpdateToOneWithWhereWithoutAnalysesInput, VoiceEnrollmentUpdateWithoutAnalysesInput>, VoiceEnrollmentUncheckedUpdateWithoutAnalysesInput>
  }

  export type UserUpdateOneRequiredWithoutVoiceAnalysesNestedInput = {
    create?: XOR<UserCreateWithoutVoiceAnalysesInput, UserUncheckedCreateWithoutVoiceAnalysesInput>
    connectOrCreate?: UserCreateOrConnectWithoutVoiceAnalysesInput
    upsert?: UserUpsertWithoutVoiceAnalysesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutVoiceAnalysesInput, UserUpdateWithoutVoiceAnalysesInput>, UserUncheckedUpdateWithoutVoiceAnalysesInput>
  }

  export type UserCreateNestedOneWithoutSpamFeedbackInput = {
    create?: XOR<UserCreateWithoutSpamFeedbackInput, UserUncheckedCreateWithoutSpamFeedbackInput>
    connectOrCreate?: UserCreateOrConnectWithoutSpamFeedbackInput
    connect?: UserWhereUniqueInput
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumFeedbackTypeFieldUpdateOperationsInput = {
    set?: $Enums.FeedbackType
  }

  export type UserUpdateOneRequiredWithoutSpamFeedbackNestedInput = {
    create?: XOR<UserCreateWithoutSpamFeedbackInput, UserUncheckedCreateWithoutSpamFeedbackInput>
    connectOrCreate?: UserCreateOrConnectWithoutSpamFeedbackInput
    upsert?: UserUpsertWithoutSpamFeedbackInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSpamFeedbackInput, UserUpdateWithoutSpamFeedbackInput>, UserUncheckedUpdateWithoutSpamFeedbackInput>
  }

  export type UserCreateNestedOneWithoutSpamRulesInput = {
    create?: XOR<UserCreateWithoutSpamRulesInput, UserUncheckedCreateWithoutSpamRulesInput>
    connectOrCreate?: UserCreateOrConnectWithoutSpamRulesInput
    connect?: UserWhereUniqueInput
  }

  export type EnumRuleTypeFieldUpdateOperationsInput = {
    set?: $Enums.RuleType
  }

  export type EnumRuleActionFieldUpdateOperationsInput = {
    set?: $Enums.RuleAction
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserUpdateOneWithoutSpamRulesNestedInput = {
    create?: XOR<UserCreateWithoutSpamRulesInput, UserUncheckedCreateWithoutSpamRulesInput>
    connectOrCreate?: UserCreateOrConnectWithoutSpamRulesInput
    upsert?: UserUpsertWithoutSpamRulesInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSpamRulesInput, UserUpdateWithoutSpamRulesInput>, UserUncheckedUpdateWithoutSpamRulesInput>
  }

  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 NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedEnumUserRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
  }

  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 NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedEnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumUserRoleFilter<$PrismaModel>
    _max?: NestedEnumUserRoleFilter<$PrismaModel>
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type 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 NestedEnumFamilyMemberRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.FamilyMemberRole | EnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    in?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumFamilyMemberRoleFilter<$PrismaModel> | $Enums.FamilyMemberRole
  }

  export type NestedEnumFamilyMemberRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FamilyMemberRole | EnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    in?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.FamilyMemberRole[] | ListEnumFamilyMemberRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumFamilyMemberRoleWithAggregatesFilter<$PrismaModel> | $Enums.FamilyMemberRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFamilyMemberRoleFilter<$PrismaModel>
    _max?: NestedEnumFamilyMemberRoleFilter<$PrismaModel>
  }

  export type NestedEnumSubscriptionTierFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionTier | EnumSubscriptionTierFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionTierFilter<$PrismaModel> | $Enums.SubscriptionTier
  }

  export type NestedEnumSubscriptionStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionStatus | EnumSubscriptionStatusFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionStatusFilter<$PrismaModel> | $Enums.SubscriptionStatus
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedEnumSubscriptionTierWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionTier | EnumSubscriptionTierFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionTier[] | ListEnumSubscriptionTierFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionTierWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionTier
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSubscriptionTierFilter<$PrismaModel>
    _max?: NestedEnumSubscriptionTierFilter<$PrismaModel>
  }

  export type NestedEnumSubscriptionStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SubscriptionStatus | EnumSubscriptionStatusFieldRefInput<$PrismaModel>
    in?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.SubscriptionStatus[] | ListEnumSubscriptionStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumSubscriptionStatusWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSubscriptionStatusFilter<$PrismaModel>
    _max?: NestedEnumSubscriptionStatusFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedEnumWatchlistTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.WatchlistType | EnumWatchlistTypeFieldRefInput<$PrismaModel>
    in?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumWatchlistTypeFilter<$PrismaModel> | $Enums.WatchlistType
  }

  export type NestedEnumWatchlistTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.WatchlistType | EnumWatchlistTypeFieldRefInput<$PrismaModel>
    in?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.WatchlistType[] | ListEnumWatchlistTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumWatchlistTypeWithAggregatesFilter<$PrismaModel> | $Enums.WatchlistType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumWatchlistTypeFilter<$PrismaModel>
    _max?: NestedEnumWatchlistTypeFilter<$PrismaModel>
  }

  export type NestedEnumExposureSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSource | EnumExposureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSourceFilter<$PrismaModel> | $Enums.ExposureSource
  }

  export type NestedEnumExposureSeverityFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSeverity | EnumExposureSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSeverityFilter<$PrismaModel> | $Enums.ExposureSeverity
  }

  export type NestedEnumExposureSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSource | EnumExposureSourceFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSource[] | ListEnumExposureSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSourceWithAggregatesFilter<$PrismaModel> | $Enums.ExposureSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExposureSourceFilter<$PrismaModel>
    _max?: NestedEnumExposureSourceFilter<$PrismaModel>
  }

  export type NestedEnumExposureSeverityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExposureSeverity | EnumExposureSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExposureSeverity[] | ListEnumExposureSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumExposureSeverityWithAggregatesFilter<$PrismaModel> | $Enums.ExposureSeverity
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExposureSeverityFilter<$PrismaModel>
    _max?: NestedEnumExposureSeverityFilter<$PrismaModel>
  }
  export type NestedJsonNullableFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumAlertTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertType | EnumAlertTypeFieldRefInput<$PrismaModel>
    in?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertTypeFilter<$PrismaModel> | $Enums.AlertType
  }

  export type NestedEnumAlertSeverityFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertSeverity | EnumAlertSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertSeverityFilter<$PrismaModel> | $Enums.AlertSeverity
  }

  export type NestedEnumAlertTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertType | EnumAlertTypeFieldRefInput<$PrismaModel>
    in?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertType[] | ListEnumAlertTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertTypeWithAggregatesFilter<$PrismaModel> | $Enums.AlertType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAlertTypeFilter<$PrismaModel>
    _max?: NestedEnumAlertTypeFilter<$PrismaModel>
  }

  export type NestedEnumAlertSeverityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AlertSeverity | EnumAlertSeverityFieldRefInput<$PrismaModel>
    in?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    notIn?: $Enums.AlertSeverity[] | ListEnumAlertSeverityFieldRefInput<$PrismaModel>
    not?: NestedEnumAlertSeverityWithAggregatesFilter<$PrismaModel> | $Enums.AlertSeverity
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAlertSeverityFilter<$PrismaModel>
    _max?: NestedEnumAlertSeverityFilter<$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 NestedFloatWithAggregatesFilter<$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?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }
  export type NestedJsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumFeedbackTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.FeedbackType | EnumFeedbackTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumFeedbackTypeFilter<$PrismaModel> | $Enums.FeedbackType
  }

  export type NestedFloatNullableWithAggregatesFilter<$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?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedEnumFeedbackTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FeedbackType | EnumFeedbackTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.FeedbackType[] | ListEnumFeedbackTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumFeedbackTypeWithAggregatesFilter<$PrismaModel> | $Enums.FeedbackType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFeedbackTypeFilter<$PrismaModel>
    _max?: NestedEnumFeedbackTypeFilter<$PrismaModel>
  }

  export type NestedEnumRuleTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleType | EnumRuleTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleTypeFilter<$PrismaModel> | $Enums.RuleType
  }

  export type NestedEnumRuleActionFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleAction | EnumRuleActionFieldRefInput<$PrismaModel>
    in?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionFilter<$PrismaModel> | $Enums.RuleAction
  }

  export type NestedEnumRuleTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleType | EnumRuleTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleType[] | ListEnumRuleTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleTypeFilter<$PrismaModel>
  }

  export type NestedEnumRuleActionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleAction | EnumRuleActionFieldRefInput<$PrismaModel>
    in?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleAction[] | ListEnumRuleActionFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionWithAggregatesFilter<$PrismaModel> | $Enums.RuleAction
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleActionFilter<$PrismaModel>
    _max?: NestedEnumRuleActionFilter<$PrismaModel>
  }

  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 AccountCreateWithoutUserInput = {
    id?: string
    provider: string
    providerAccountId: string
    access_token?: string | null
    refresh_token?: string | null
    expires_at?: number | null
    token_type?: string | null
    scope?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

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

  export type AccountCreateOrConnectWithoutUserInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountCreateManyUserInputEnvelope = {
    data: AccountCreateManyUserInput | AccountCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SessionCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUncheckedCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionCreateOrConnectWithoutUserInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionCreateManyUserInputEnvelope = {
    data: SessionCreateManyUserInput | SessionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type FamilyGroupMemberCreateWithoutUserInput = {
    id?: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    group: FamilyGroupCreateNestedOneWithoutMembersInput
  }

  export type FamilyGroupMemberUncheckedCreateWithoutUserInput = {
    id?: string
    groupId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberCreateOrConnectWithoutUserInput = {
    where: FamilyGroupMemberWhereUniqueInput
    create: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput>
  }

  export type FamilyGroupMemberCreateManyUserInputEnvelope = {
    data: FamilyGroupMemberCreateManyUserInput | FamilyGroupMemberCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type FamilyGroupCreateWithoutOwnerInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    members?: FamilyGroupMemberCreateNestedManyWithoutGroupInput
    subscriptions?: SubscriptionCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupUncheckedCreateWithoutOwnerInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    members?: FamilyGroupMemberUncheckedCreateNestedManyWithoutGroupInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupCreateOrConnectWithoutOwnerInput = {
    where: FamilyGroupWhereUniqueInput
    create: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput>
  }

  export type FamilyGroupCreateManyOwnerInputEnvelope = {
    data: FamilyGroupCreateManyOwnerInput | FamilyGroupCreateManyOwnerInput[]
    skipDuplicates?: boolean
  }

  export type SubscriptionCreateWithoutUserInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    familyGroup?: FamilyGroupCreateNestedOneWithoutSubscriptionsInput
    watchlistItems?: WatchlistItemCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateWithoutUserInput = {
    id?: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItems?: WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureUncheckedCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionCreateOrConnectWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput>
  }

  export type SubscriptionCreateManyUserInputEnvelope = {
    data: SubscriptionCreateManyUserInput | SubscriptionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AlertCreateWithoutUserInput = {
    id?: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutAlertsInput
    exposure?: ExposureCreateNestedOneWithoutAlertsInput
  }

  export type AlertUncheckedCreateWithoutUserInput = {
    id?: string
    subscriptionId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertCreateOrConnectWithoutUserInput = {
    where: AlertWhereUniqueInput
    create: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput>
  }

  export type AlertCreateManyUserInputEnvelope = {
    data: AlertCreateManyUserInput | AlertCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type VoiceEnrollmentCreateWithoutUserInput = {
    id?: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    analyses?: VoiceAnalysisCreateNestedManyWithoutEnrollmentInput
  }

  export type VoiceEnrollmentUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    analyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutEnrollmentInput
  }

  export type VoiceEnrollmentCreateOrConnectWithoutUserInput = {
    where: VoiceEnrollmentWhereUniqueInput
    create: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput>
  }

  export type VoiceEnrollmentCreateManyUserInputEnvelope = {
    data: VoiceEnrollmentCreateManyUserInput | VoiceEnrollmentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type VoiceAnalysisCreateWithoutUserInput = {
    id?: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
    enrollment?: VoiceEnrollmentCreateNestedOneWithoutAnalysesInput
  }

  export type VoiceAnalysisUncheckedCreateWithoutUserInput = {
    id?: string
    enrollmentId?: string | null
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type VoiceAnalysisCreateOrConnectWithoutUserInput = {
    where: VoiceAnalysisWhereUniqueInput
    create: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput>
  }

  export type VoiceAnalysisCreateManyUserInputEnvelope = {
    data: VoiceAnalysisCreateManyUserInput | VoiceAnalysisCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SpamFeedbackCreateWithoutUserInput = {
    id?: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamFeedbackUncheckedCreateWithoutUserInput = {
    id?: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamFeedbackCreateOrConnectWithoutUserInput = {
    where: SpamFeedbackWhereUniqueInput
    create: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput>
  }

  export type SpamFeedbackCreateManyUserInputEnvelope = {
    data: SpamFeedbackCreateManyUserInput | SpamFeedbackCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SpamRuleCreateWithoutUserInput = {
    id?: string
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamRuleUncheckedCreateWithoutUserInput = {
    id?: string
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamRuleCreateOrConnectWithoutUserInput = {
    where: SpamRuleWhereUniqueInput
    create: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput>
  }

  export type SpamRuleCreateManyUserInputEnvelope = {
    data: SpamRuleCreateManyUserInput | SpamRuleCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AccountUpsertWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    update: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountUpdateWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    data: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
  }

  export type AccountUpdateManyWithWhereWithoutUserInput = {
    where: AccountScalarWhereInput
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutUserInput>
  }

  export type AccountScalarWhereInput = {
    AND?: AccountScalarWhereInput | AccountScalarWhereInput[]
    OR?: AccountScalarWhereInput[]
    NOT?: AccountScalarWhereInput | AccountScalarWhereInput[]
    id?: StringFilter<"Account"> | string
    userId?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    access_token?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
  }

  export type SessionUpsertWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    update: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionUpdateWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    data: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
  }

  export type SessionUpdateManyWithWhereWithoutUserInput = {
    where: SessionScalarWhereInput
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutUserInput>
  }

  export type SessionScalarWhereInput = {
    AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
    OR?: SessionScalarWhereInput[]
    NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
    id?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
  }

  export type FamilyGroupMemberUpsertWithWhereUniqueWithoutUserInput = {
    where: FamilyGroupMemberWhereUniqueInput
    update: XOR<FamilyGroupMemberUpdateWithoutUserInput, FamilyGroupMemberUncheckedUpdateWithoutUserInput>
    create: XOR<FamilyGroupMemberCreateWithoutUserInput, FamilyGroupMemberUncheckedCreateWithoutUserInput>
  }

  export type FamilyGroupMemberUpdateWithWhereUniqueWithoutUserInput = {
    where: FamilyGroupMemberWhereUniqueInput
    data: XOR<FamilyGroupMemberUpdateWithoutUserInput, FamilyGroupMemberUncheckedUpdateWithoutUserInput>
  }

  export type FamilyGroupMemberUpdateManyWithWhereWithoutUserInput = {
    where: FamilyGroupMemberScalarWhereInput
    data: XOR<FamilyGroupMemberUpdateManyMutationInput, FamilyGroupMemberUncheckedUpdateManyWithoutUserInput>
  }

  export type FamilyGroupMemberScalarWhereInput = {
    AND?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
    OR?: FamilyGroupMemberScalarWhereInput[]
    NOT?: FamilyGroupMemberScalarWhereInput | FamilyGroupMemberScalarWhereInput[]
    id?: StringFilter<"FamilyGroupMember"> | string
    groupId?: StringFilter<"FamilyGroupMember"> | string
    userId?: StringFilter<"FamilyGroupMember"> | string
    role?: EnumFamilyMemberRoleFilter<"FamilyGroupMember"> | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    createdAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroupMember"> | Date | string
  }

  export type FamilyGroupUpsertWithWhereUniqueWithoutOwnerInput = {
    where: FamilyGroupWhereUniqueInput
    update: XOR<FamilyGroupUpdateWithoutOwnerInput, FamilyGroupUncheckedUpdateWithoutOwnerInput>
    create: XOR<FamilyGroupCreateWithoutOwnerInput, FamilyGroupUncheckedCreateWithoutOwnerInput>
  }

  export type FamilyGroupUpdateWithWhereUniqueWithoutOwnerInput = {
    where: FamilyGroupWhereUniqueInput
    data: XOR<FamilyGroupUpdateWithoutOwnerInput, FamilyGroupUncheckedUpdateWithoutOwnerInput>
  }

  export type FamilyGroupUpdateManyWithWhereWithoutOwnerInput = {
    where: FamilyGroupScalarWhereInput
    data: XOR<FamilyGroupUpdateManyMutationInput, FamilyGroupUncheckedUpdateManyWithoutOwnerInput>
  }

  export type FamilyGroupScalarWhereInput = {
    AND?: FamilyGroupScalarWhereInput | FamilyGroupScalarWhereInput[]
    OR?: FamilyGroupScalarWhereInput[]
    NOT?: FamilyGroupScalarWhereInput | FamilyGroupScalarWhereInput[]
    id?: StringFilter<"FamilyGroup"> | string
    name?: StringFilter<"FamilyGroup"> | string
    ownerId?: StringFilter<"FamilyGroup"> | string
    createdAt?: DateTimeFilter<"FamilyGroup"> | Date | string
    updatedAt?: DateTimeFilter<"FamilyGroup"> | Date | string
  }

  export type SubscriptionUpsertWithWhereUniqueWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    update: XOR<SubscriptionUpdateWithoutUserInput, SubscriptionUncheckedUpdateWithoutUserInput>
    create: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput>
  }

  export type SubscriptionUpdateWithWhereUniqueWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    data: XOR<SubscriptionUpdateWithoutUserInput, SubscriptionUncheckedUpdateWithoutUserInput>
  }

  export type SubscriptionUpdateManyWithWhereWithoutUserInput = {
    where: SubscriptionScalarWhereInput
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyWithoutUserInput>
  }

  export type SubscriptionScalarWhereInput = {
    AND?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
    OR?: SubscriptionScalarWhereInput[]
    NOT?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
    id?: StringFilter<"Subscription"> | string
    userId?: StringFilter<"Subscription"> | string
    familyGroupId?: StringNullableFilter<"Subscription"> | string | null
    stripeId?: StringNullableFilter<"Subscription"> | string | null
    tier?: EnumSubscriptionTierFilter<"Subscription"> | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFilter<"Subscription"> | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFilter<"Subscription"> | Date | string
    currentPeriodEnd?: DateTimeFilter<"Subscription"> | Date | string
    cancelAtPeriodEnd?: BoolFilter<"Subscription"> | boolean
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
  }

  export type AlertUpsertWithWhereUniqueWithoutUserInput = {
    where: AlertWhereUniqueInput
    update: XOR<AlertUpdateWithoutUserInput, AlertUncheckedUpdateWithoutUserInput>
    create: XOR<AlertCreateWithoutUserInput, AlertUncheckedCreateWithoutUserInput>
  }

  export type AlertUpdateWithWhereUniqueWithoutUserInput = {
    where: AlertWhereUniqueInput
    data: XOR<AlertUpdateWithoutUserInput, AlertUncheckedUpdateWithoutUserInput>
  }

  export type AlertUpdateManyWithWhereWithoutUserInput = {
    where: AlertScalarWhereInput
    data: XOR<AlertUpdateManyMutationInput, AlertUncheckedUpdateManyWithoutUserInput>
  }

  export type AlertScalarWhereInput = {
    AND?: AlertScalarWhereInput | AlertScalarWhereInput[]
    OR?: AlertScalarWhereInput[]
    NOT?: AlertScalarWhereInput | AlertScalarWhereInput[]
    id?: StringFilter<"Alert"> | string
    subscriptionId?: StringFilter<"Alert"> | string
    userId?: StringFilter<"Alert"> | string
    exposureId?: StringNullableFilter<"Alert"> | string | null
    type?: EnumAlertTypeFilter<"Alert"> | $Enums.AlertType
    title?: StringFilter<"Alert"> | string
    message?: StringFilter<"Alert"> | string
    severity?: EnumAlertSeverityFilter<"Alert"> | $Enums.AlertSeverity
    isRead?: BoolFilter<"Alert"> | boolean
    readAt?: DateTimeNullableFilter<"Alert"> | Date | string | null
    channel?: EnumAlertChannelNullableListFilter<"Alert">
    createdAt?: DateTimeFilter<"Alert"> | Date | string
    updatedAt?: DateTimeFilter<"Alert"> | Date | string
  }

  export type VoiceEnrollmentUpsertWithWhereUniqueWithoutUserInput = {
    where: VoiceEnrollmentWhereUniqueInput
    update: XOR<VoiceEnrollmentUpdateWithoutUserInput, VoiceEnrollmentUncheckedUpdateWithoutUserInput>
    create: XOR<VoiceEnrollmentCreateWithoutUserInput, VoiceEnrollmentUncheckedCreateWithoutUserInput>
  }

  export type VoiceEnrollmentUpdateWithWhereUniqueWithoutUserInput = {
    where: VoiceEnrollmentWhereUniqueInput
    data: XOR<VoiceEnrollmentUpdateWithoutUserInput, VoiceEnrollmentUncheckedUpdateWithoutUserInput>
  }

  export type VoiceEnrollmentUpdateManyWithWhereWithoutUserInput = {
    where: VoiceEnrollmentScalarWhereInput
    data: XOR<VoiceEnrollmentUpdateManyMutationInput, VoiceEnrollmentUncheckedUpdateManyWithoutUserInput>
  }

  export type VoiceEnrollmentScalarWhereInput = {
    AND?: VoiceEnrollmentScalarWhereInput | VoiceEnrollmentScalarWhereInput[]
    OR?: VoiceEnrollmentScalarWhereInput[]
    NOT?: VoiceEnrollmentScalarWhereInput | VoiceEnrollmentScalarWhereInput[]
    id?: StringFilter<"VoiceEnrollment"> | string
    userId?: StringFilter<"VoiceEnrollment"> | string
    name?: StringFilter<"VoiceEnrollment"> | string
    voiceHash?: StringFilter<"VoiceEnrollment"> | string
    audioMetadata?: JsonNullableFilter<"VoiceEnrollment">
    isActive?: BoolFilter<"VoiceEnrollment"> | boolean
    createdAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
    updatedAt?: DateTimeFilter<"VoiceEnrollment"> | Date | string
  }

  export type VoiceAnalysisUpsertWithWhereUniqueWithoutUserInput = {
    where: VoiceAnalysisWhereUniqueInput
    update: XOR<VoiceAnalysisUpdateWithoutUserInput, VoiceAnalysisUncheckedUpdateWithoutUserInput>
    create: XOR<VoiceAnalysisCreateWithoutUserInput, VoiceAnalysisUncheckedCreateWithoutUserInput>
  }

  export type VoiceAnalysisUpdateWithWhereUniqueWithoutUserInput = {
    where: VoiceAnalysisWhereUniqueInput
    data: XOR<VoiceAnalysisUpdateWithoutUserInput, VoiceAnalysisUncheckedUpdateWithoutUserInput>
  }

  export type VoiceAnalysisUpdateManyWithWhereWithoutUserInput = {
    where: VoiceAnalysisScalarWhereInput
    data: XOR<VoiceAnalysisUpdateManyMutationInput, VoiceAnalysisUncheckedUpdateManyWithoutUserInput>
  }

  export type VoiceAnalysisScalarWhereInput = {
    AND?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
    OR?: VoiceAnalysisScalarWhereInput[]
    NOT?: VoiceAnalysisScalarWhereInput | VoiceAnalysisScalarWhereInput[]
    id?: StringFilter<"VoiceAnalysis"> | string
    enrollmentId?: StringNullableFilter<"VoiceAnalysis"> | string | null
    userId?: StringFilter<"VoiceAnalysis"> | string
    audioHash?: StringFilter<"VoiceAnalysis"> | string
    isSynthetic?: BoolFilter<"VoiceAnalysis"> | boolean
    confidence?: FloatFilter<"VoiceAnalysis"> | number
    analysisResult?: JsonFilter<"VoiceAnalysis">
    audioUrl?: StringFilter<"VoiceAnalysis"> | string
    createdAt?: DateTimeFilter<"VoiceAnalysis"> | Date | string
  }

  export type SpamFeedbackUpsertWithWhereUniqueWithoutUserInput = {
    where: SpamFeedbackWhereUniqueInput
    update: XOR<SpamFeedbackUpdateWithoutUserInput, SpamFeedbackUncheckedUpdateWithoutUserInput>
    create: XOR<SpamFeedbackCreateWithoutUserInput, SpamFeedbackUncheckedCreateWithoutUserInput>
  }

  export type SpamFeedbackUpdateWithWhereUniqueWithoutUserInput = {
    where: SpamFeedbackWhereUniqueInput
    data: XOR<SpamFeedbackUpdateWithoutUserInput, SpamFeedbackUncheckedUpdateWithoutUserInput>
  }

  export type SpamFeedbackUpdateManyWithWhereWithoutUserInput = {
    where: SpamFeedbackScalarWhereInput
    data: XOR<SpamFeedbackUpdateManyMutationInput, SpamFeedbackUncheckedUpdateManyWithoutUserInput>
  }

  export type SpamFeedbackScalarWhereInput = {
    AND?: SpamFeedbackScalarWhereInput | SpamFeedbackScalarWhereInput[]
    OR?: SpamFeedbackScalarWhereInput[]
    NOT?: SpamFeedbackScalarWhereInput | SpamFeedbackScalarWhereInput[]
    id?: StringFilter<"SpamFeedback"> | string
    userId?: StringFilter<"SpamFeedback"> | string
    phoneNumber?: StringFilter<"SpamFeedback"> | string
    phoneNumberHash?: StringFilter<"SpamFeedback"> | string
    isSpam?: BoolFilter<"SpamFeedback"> | boolean
    confidence?: FloatNullableFilter<"SpamFeedback"> | number | null
    feedbackType?: EnumFeedbackTypeFilter<"SpamFeedback"> | $Enums.FeedbackType
    metadata?: JsonNullableFilter<"SpamFeedback">
    createdAt?: DateTimeFilter<"SpamFeedback"> | Date | string
    updatedAt?: DateTimeFilter<"SpamFeedback"> | Date | string
  }

  export type SpamRuleUpsertWithWhereUniqueWithoutUserInput = {
    where: SpamRuleWhereUniqueInput
    update: XOR<SpamRuleUpdateWithoutUserInput, SpamRuleUncheckedUpdateWithoutUserInput>
    create: XOR<SpamRuleCreateWithoutUserInput, SpamRuleUncheckedCreateWithoutUserInput>
  }

  export type SpamRuleUpdateWithWhereUniqueWithoutUserInput = {
    where: SpamRuleWhereUniqueInput
    data: XOR<SpamRuleUpdateWithoutUserInput, SpamRuleUncheckedUpdateWithoutUserInput>
  }

  export type SpamRuleUpdateManyWithWhereWithoutUserInput = {
    where: SpamRuleScalarWhereInput
    data: XOR<SpamRuleUpdateManyMutationInput, SpamRuleUncheckedUpdateManyWithoutUserInput>
  }

  export type SpamRuleScalarWhereInput = {
    AND?: SpamRuleScalarWhereInput | SpamRuleScalarWhereInput[]
    OR?: SpamRuleScalarWhereInput[]
    NOT?: SpamRuleScalarWhereInput | SpamRuleScalarWhereInput[]
    id?: StringFilter<"SpamRule"> | string
    userId?: StringNullableFilter<"SpamRule"> | string | null
    isGlobal?: BoolFilter<"SpamRule"> | boolean
    ruleType?: EnumRuleTypeFilter<"SpamRule"> | $Enums.RuleType
    pattern?: StringFilter<"SpamRule"> | string
    action?: EnumRuleActionFilter<"SpamRule"> | $Enums.RuleAction
    priority?: IntFilter<"SpamRule"> | number
    isActive?: BoolFilter<"SpamRule"> | boolean
    createdAt?: DateTimeFilter<"SpamRule"> | Date | string
    updatedAt?: DateTimeFilter<"SpamRule"> | Date | string
  }

  export type UserCreateWithoutAccountsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccountsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccountsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
  }

  export type UserUpsertWithoutAccountsInput = {
    update: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccountsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
  }

  export type UserUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSessionsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
  }

  export type UserUpsertWithoutSessionsInput = {
    update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutFamilyGroupOwnedInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutFamilyGroupOwnedInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutFamilyGroupOwnedInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutFamilyGroupOwnedInput, UserUncheckedCreateWithoutFamilyGroupOwnedInput>
  }

  export type FamilyGroupMemberCreateWithoutGroupInput = {
    id?: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutFamilyGroupsInput
  }

  export type FamilyGroupMemberUncheckedCreateWithoutGroupInput = {
    id?: string
    userId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberCreateOrConnectWithoutGroupInput = {
    where: FamilyGroupMemberWhereUniqueInput
    create: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput>
  }

  export type FamilyGroupMemberCreateManyGroupInputEnvelope = {
    data: FamilyGroupMemberCreateManyGroupInput | FamilyGroupMemberCreateManyGroupInput[]
    skipDuplicates?: boolean
  }

  export type SubscriptionCreateWithoutFamilyGroupInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
    watchlistItems?: WatchlistItemCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateWithoutFamilyGroupInput = {
    id?: string
    userId: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItems?: WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureUncheckedCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionCreateOrConnectWithoutFamilyGroupInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput>
  }

  export type SubscriptionCreateManyFamilyGroupInputEnvelope = {
    data: SubscriptionCreateManyFamilyGroupInput | SubscriptionCreateManyFamilyGroupInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutFamilyGroupOwnedInput = {
    update: XOR<UserUpdateWithoutFamilyGroupOwnedInput, UserUncheckedUpdateWithoutFamilyGroupOwnedInput>
    create: XOR<UserCreateWithoutFamilyGroupOwnedInput, UserUncheckedCreateWithoutFamilyGroupOwnedInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutFamilyGroupOwnedInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutFamilyGroupOwnedInput, UserUncheckedUpdateWithoutFamilyGroupOwnedInput>
  }

  export type UserUpdateWithoutFamilyGroupOwnedInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutFamilyGroupOwnedInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type FamilyGroupMemberUpsertWithWhereUniqueWithoutGroupInput = {
    where: FamilyGroupMemberWhereUniqueInput
    update: XOR<FamilyGroupMemberUpdateWithoutGroupInput, FamilyGroupMemberUncheckedUpdateWithoutGroupInput>
    create: XOR<FamilyGroupMemberCreateWithoutGroupInput, FamilyGroupMemberUncheckedCreateWithoutGroupInput>
  }

  export type FamilyGroupMemberUpdateWithWhereUniqueWithoutGroupInput = {
    where: FamilyGroupMemberWhereUniqueInput
    data: XOR<FamilyGroupMemberUpdateWithoutGroupInput, FamilyGroupMemberUncheckedUpdateWithoutGroupInput>
  }

  export type FamilyGroupMemberUpdateManyWithWhereWithoutGroupInput = {
    where: FamilyGroupMemberScalarWhereInput
    data: XOR<FamilyGroupMemberUpdateManyMutationInput, FamilyGroupMemberUncheckedUpdateManyWithoutGroupInput>
  }

  export type SubscriptionUpsertWithWhereUniqueWithoutFamilyGroupInput = {
    where: SubscriptionWhereUniqueInput
    update: XOR<SubscriptionUpdateWithoutFamilyGroupInput, SubscriptionUncheckedUpdateWithoutFamilyGroupInput>
    create: XOR<SubscriptionCreateWithoutFamilyGroupInput, SubscriptionUncheckedCreateWithoutFamilyGroupInput>
  }

  export type SubscriptionUpdateWithWhereUniqueWithoutFamilyGroupInput = {
    where: SubscriptionWhereUniqueInput
    data: XOR<SubscriptionUpdateWithoutFamilyGroupInput, SubscriptionUncheckedUpdateWithoutFamilyGroupInput>
  }

  export type SubscriptionUpdateManyWithWhereWithoutFamilyGroupInput = {
    where: SubscriptionScalarWhereInput
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyWithoutFamilyGroupInput>
  }

  export type FamilyGroupCreateWithoutMembersInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    owner: UserCreateNestedOneWithoutFamilyGroupOwnedInput
    subscriptions?: SubscriptionCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupUncheckedCreateWithoutMembersInput = {
    id?: string
    name: string
    ownerId: string
    createdAt?: Date | string
    updatedAt?: Date | string
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutFamilyGroupInput
  }

  export type FamilyGroupCreateOrConnectWithoutMembersInput = {
    where: FamilyGroupWhereUniqueInput
    create: XOR<FamilyGroupCreateWithoutMembersInput, FamilyGroupUncheckedCreateWithoutMembersInput>
  }

  export type UserCreateWithoutFamilyGroupsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutFamilyGroupsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutFamilyGroupsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutFamilyGroupsInput, UserUncheckedCreateWithoutFamilyGroupsInput>
  }

  export type FamilyGroupUpsertWithoutMembersInput = {
    update: XOR<FamilyGroupUpdateWithoutMembersInput, FamilyGroupUncheckedUpdateWithoutMembersInput>
    create: XOR<FamilyGroupCreateWithoutMembersInput, FamilyGroupUncheckedCreateWithoutMembersInput>
    where?: FamilyGroupWhereInput
  }

  export type FamilyGroupUpdateToOneWithWhereWithoutMembersInput = {
    where?: FamilyGroupWhereInput
    data: XOR<FamilyGroupUpdateWithoutMembersInput, FamilyGroupUncheckedUpdateWithoutMembersInput>
  }

  export type FamilyGroupUpdateWithoutMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    owner?: UserUpdateOneRequiredWithoutFamilyGroupOwnedNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutFamilyGroupNestedInput
  }

  export type FamilyGroupUncheckedUpdateWithoutMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    ownerId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutFamilyGroupNestedInput
  }

  export type UserUpsertWithoutFamilyGroupsInput = {
    update: XOR<UserUpdateWithoutFamilyGroupsInput, UserUncheckedUpdateWithoutFamilyGroupsInput>
    create: XOR<UserCreateWithoutFamilyGroupsInput, UserUncheckedCreateWithoutFamilyGroupsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutFamilyGroupsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutFamilyGroupsInput, UserUncheckedUpdateWithoutFamilyGroupsInput>
  }

  export type UserUpdateWithoutFamilyGroupsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutFamilyGroupsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSubscriptionsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSubscriptionsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSubscriptionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
  }

  export type FamilyGroupCreateWithoutSubscriptionsInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
    owner: UserCreateNestedOneWithoutFamilyGroupOwnedInput
    members?: FamilyGroupMemberCreateNestedManyWithoutGroupInput
  }

  export type FamilyGroupUncheckedCreateWithoutSubscriptionsInput = {
    id?: string
    name: string
    ownerId: string
    createdAt?: Date | string
    updatedAt?: Date | string
    members?: FamilyGroupMemberUncheckedCreateNestedManyWithoutGroupInput
  }

  export type FamilyGroupCreateOrConnectWithoutSubscriptionsInput = {
    where: FamilyGroupWhereUniqueInput
    create: XOR<FamilyGroupCreateWithoutSubscriptionsInput, FamilyGroupUncheckedCreateWithoutSubscriptionsInput>
  }

  export type WatchlistItemCreateWithoutSubscriptionInput = {
    id?: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exposures?: ExposureCreateNestedManyWithoutWatchlistItemInput
  }

  export type WatchlistItemUncheckedCreateWithoutSubscriptionInput = {
    id?: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exposures?: ExposureUncheckedCreateNestedManyWithoutWatchlistItemInput
  }

  export type WatchlistItemCreateOrConnectWithoutSubscriptionInput = {
    where: WatchlistItemWhereUniqueInput
    create: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput>
  }

  export type WatchlistItemCreateManySubscriptionInputEnvelope = {
    data: WatchlistItemCreateManySubscriptionInput | WatchlistItemCreateManySubscriptionInput[]
    skipDuplicates?: boolean
  }

  export type ExposureCreateWithoutSubscriptionInput = {
    id?: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItem?: WatchlistItemCreateNestedOneWithoutExposuresInput
    alerts?: AlertCreateNestedManyWithoutExposureInput
  }

  export type ExposureUncheckedCreateWithoutSubscriptionInput = {
    id?: string
    watchlistItemId?: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    alerts?: AlertUncheckedCreateNestedManyWithoutExposureInput
  }

  export type ExposureCreateOrConnectWithoutSubscriptionInput = {
    where: ExposureWhereUniqueInput
    create: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput>
  }

  export type ExposureCreateManySubscriptionInputEnvelope = {
    data: ExposureCreateManySubscriptionInput | ExposureCreateManySubscriptionInput[]
    skipDuplicates?: boolean
  }

  export type AlertCreateWithoutSubscriptionInput = {
    id?: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAlertsInput
    exposure?: ExposureCreateNestedOneWithoutAlertsInput
  }

  export type AlertUncheckedCreateWithoutSubscriptionInput = {
    id?: string
    userId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertCreateOrConnectWithoutSubscriptionInput = {
    where: AlertWhereUniqueInput
    create: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput>
  }

  export type AlertCreateManySubscriptionInputEnvelope = {
    data: AlertCreateManySubscriptionInput | AlertCreateManySubscriptionInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutSubscriptionsInput = {
    update: XOR<UserUpdateWithoutSubscriptionsInput, UserUncheckedUpdateWithoutSubscriptionsInput>
    create: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSubscriptionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSubscriptionsInput, UserUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type UserUpdateWithoutSubscriptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSubscriptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type FamilyGroupUpsertWithoutSubscriptionsInput = {
    update: XOR<FamilyGroupUpdateWithoutSubscriptionsInput, FamilyGroupUncheckedUpdateWithoutSubscriptionsInput>
    create: XOR<FamilyGroupCreateWithoutSubscriptionsInput, FamilyGroupUncheckedCreateWithoutSubscriptionsInput>
    where?: FamilyGroupWhereInput
  }

  export type FamilyGroupUpdateToOneWithWhereWithoutSubscriptionsInput = {
    where?: FamilyGroupWhereInput
    data: XOR<FamilyGroupUpdateWithoutSubscriptionsInput, FamilyGroupUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type FamilyGroupUpdateWithoutSubscriptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    owner?: UserUpdateOneRequiredWithoutFamilyGroupOwnedNestedInput
    members?: FamilyGroupMemberUpdateManyWithoutGroupNestedInput
  }

  export type FamilyGroupUncheckedUpdateWithoutSubscriptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    ownerId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    members?: FamilyGroupMemberUncheckedUpdateManyWithoutGroupNestedInput
  }

  export type WatchlistItemUpsertWithWhereUniqueWithoutSubscriptionInput = {
    where: WatchlistItemWhereUniqueInput
    update: XOR<WatchlistItemUpdateWithoutSubscriptionInput, WatchlistItemUncheckedUpdateWithoutSubscriptionInput>
    create: XOR<WatchlistItemCreateWithoutSubscriptionInput, WatchlistItemUncheckedCreateWithoutSubscriptionInput>
  }

  export type WatchlistItemUpdateWithWhereUniqueWithoutSubscriptionInput = {
    where: WatchlistItemWhereUniqueInput
    data: XOR<WatchlistItemUpdateWithoutSubscriptionInput, WatchlistItemUncheckedUpdateWithoutSubscriptionInput>
  }

  export type WatchlistItemUpdateManyWithWhereWithoutSubscriptionInput = {
    where: WatchlistItemScalarWhereInput
    data: XOR<WatchlistItemUpdateManyMutationInput, WatchlistItemUncheckedUpdateManyWithoutSubscriptionInput>
  }

  export type WatchlistItemScalarWhereInput = {
    AND?: WatchlistItemScalarWhereInput | WatchlistItemScalarWhereInput[]
    OR?: WatchlistItemScalarWhereInput[]
    NOT?: WatchlistItemScalarWhereInput | WatchlistItemScalarWhereInput[]
    id?: StringFilter<"WatchlistItem"> | string
    subscriptionId?: StringFilter<"WatchlistItem"> | string
    type?: EnumWatchlistTypeFilter<"WatchlistItem"> | $Enums.WatchlistType
    value?: StringFilter<"WatchlistItem"> | string
    hash?: StringFilter<"WatchlistItem"> | string
    isActive?: BoolFilter<"WatchlistItem"> | boolean
    createdAt?: DateTimeFilter<"WatchlistItem"> | Date | string
    updatedAt?: DateTimeFilter<"WatchlistItem"> | Date | string
  }

  export type ExposureUpsertWithWhereUniqueWithoutSubscriptionInput = {
    where: ExposureWhereUniqueInput
    update: XOR<ExposureUpdateWithoutSubscriptionInput, ExposureUncheckedUpdateWithoutSubscriptionInput>
    create: XOR<ExposureCreateWithoutSubscriptionInput, ExposureUncheckedCreateWithoutSubscriptionInput>
  }

  export type ExposureUpdateWithWhereUniqueWithoutSubscriptionInput = {
    where: ExposureWhereUniqueInput
    data: XOR<ExposureUpdateWithoutSubscriptionInput, ExposureUncheckedUpdateWithoutSubscriptionInput>
  }

  export type ExposureUpdateManyWithWhereWithoutSubscriptionInput = {
    where: ExposureScalarWhereInput
    data: XOR<ExposureUpdateManyMutationInput, ExposureUncheckedUpdateManyWithoutSubscriptionInput>
  }

  export type ExposureScalarWhereInput = {
    AND?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
    OR?: ExposureScalarWhereInput[]
    NOT?: ExposureScalarWhereInput | ExposureScalarWhereInput[]
    id?: StringFilter<"Exposure"> | string
    subscriptionId?: StringFilter<"Exposure"> | string
    watchlistItemId?: StringNullableFilter<"Exposure"> | string | null
    source?: EnumExposureSourceFilter<"Exposure"> | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFilter<"Exposure"> | $Enums.WatchlistType
    identifier?: StringFilter<"Exposure"> | string
    identifierHash?: StringFilter<"Exposure"> | string
    severity?: EnumExposureSeverityFilter<"Exposure"> | $Enums.ExposureSeverity
    metadata?: JsonNullableFilter<"Exposure">
    isFirstTime?: BoolFilter<"Exposure"> | boolean
    detectedAt?: DateTimeFilter<"Exposure"> | Date | string
    createdAt?: DateTimeFilter<"Exposure"> | Date | string
    updatedAt?: DateTimeFilter<"Exposure"> | Date | string
  }

  export type AlertUpsertWithWhereUniqueWithoutSubscriptionInput = {
    where: AlertWhereUniqueInput
    update: XOR<AlertUpdateWithoutSubscriptionInput, AlertUncheckedUpdateWithoutSubscriptionInput>
    create: XOR<AlertCreateWithoutSubscriptionInput, AlertUncheckedCreateWithoutSubscriptionInput>
  }

  export type AlertUpdateWithWhereUniqueWithoutSubscriptionInput = {
    where: AlertWhereUniqueInput
    data: XOR<AlertUpdateWithoutSubscriptionInput, AlertUncheckedUpdateWithoutSubscriptionInput>
  }

  export type AlertUpdateManyWithWhereWithoutSubscriptionInput = {
    where: AlertScalarWhereInput
    data: XOR<AlertUpdateManyMutationInput, AlertUncheckedUpdateManyWithoutSubscriptionInput>
  }

  export type SubscriptionCreateWithoutWatchlistItemsInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
    familyGroup?: FamilyGroupCreateNestedOneWithoutSubscriptionsInput
    exposures?: ExposureCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateWithoutWatchlistItemsInput = {
    id?: string
    userId: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exposures?: ExposureUncheckedCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionCreateOrConnectWithoutWatchlistItemsInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutWatchlistItemsInput, SubscriptionUncheckedCreateWithoutWatchlistItemsInput>
  }

  export type ExposureCreateWithoutWatchlistItemInput = {
    id?: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutExposuresInput
    alerts?: AlertCreateNestedManyWithoutExposureInput
  }

  export type ExposureUncheckedCreateWithoutWatchlistItemInput = {
    id?: string
    subscriptionId: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    alerts?: AlertUncheckedCreateNestedManyWithoutExposureInput
  }

  export type ExposureCreateOrConnectWithoutWatchlistItemInput = {
    where: ExposureWhereUniqueInput
    create: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput>
  }

  export type ExposureCreateManyWatchlistItemInputEnvelope = {
    data: ExposureCreateManyWatchlistItemInput | ExposureCreateManyWatchlistItemInput[]
    skipDuplicates?: boolean
  }

  export type SubscriptionUpsertWithoutWatchlistItemsInput = {
    update: XOR<SubscriptionUpdateWithoutWatchlistItemsInput, SubscriptionUncheckedUpdateWithoutWatchlistItemsInput>
    create: XOR<SubscriptionCreateWithoutWatchlistItemsInput, SubscriptionUncheckedCreateWithoutWatchlistItemsInput>
    where?: SubscriptionWhereInput
  }

  export type SubscriptionUpdateToOneWithWhereWithoutWatchlistItemsInput = {
    where?: SubscriptionWhereInput
    data: XOR<SubscriptionUpdateWithoutWatchlistItemsInput, SubscriptionUncheckedUpdateWithoutWatchlistItemsInput>
  }

  export type SubscriptionUpdateWithoutWatchlistItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
    familyGroup?: FamilyGroupUpdateOneWithoutSubscriptionsNestedInput
    exposures?: ExposureUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateWithoutWatchlistItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exposures?: ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type ExposureUpsertWithWhereUniqueWithoutWatchlistItemInput = {
    where: ExposureWhereUniqueInput
    update: XOR<ExposureUpdateWithoutWatchlistItemInput, ExposureUncheckedUpdateWithoutWatchlistItemInput>
    create: XOR<ExposureCreateWithoutWatchlistItemInput, ExposureUncheckedCreateWithoutWatchlistItemInput>
  }

  export type ExposureUpdateWithWhereUniqueWithoutWatchlistItemInput = {
    where: ExposureWhereUniqueInput
    data: XOR<ExposureUpdateWithoutWatchlistItemInput, ExposureUncheckedUpdateWithoutWatchlistItemInput>
  }

  export type ExposureUpdateManyWithWhereWithoutWatchlistItemInput = {
    where: ExposureScalarWhereInput
    data: XOR<ExposureUpdateManyMutationInput, ExposureUncheckedUpdateManyWithoutWatchlistItemInput>
  }

  export type SubscriptionCreateWithoutExposuresInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
    familyGroup?: FamilyGroupCreateNestedOneWithoutSubscriptionsInput
    watchlistItems?: WatchlistItemCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateWithoutExposuresInput = {
    id?: string
    userId: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItems?: WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput
    alerts?: AlertUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionCreateOrConnectWithoutExposuresInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutExposuresInput, SubscriptionUncheckedCreateWithoutExposuresInput>
  }

  export type WatchlistItemCreateWithoutExposuresInput = {
    id?: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutWatchlistItemsInput
  }

  export type WatchlistItemUncheckedCreateWithoutExposuresInput = {
    id?: string
    subscriptionId: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WatchlistItemCreateOrConnectWithoutExposuresInput = {
    where: WatchlistItemWhereUniqueInput
    create: XOR<WatchlistItemCreateWithoutExposuresInput, WatchlistItemUncheckedCreateWithoutExposuresInput>
  }

  export type AlertCreateWithoutExposureInput = {
    id?: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutAlertsInput
    user: UserCreateNestedOneWithoutAlertsInput
  }

  export type AlertUncheckedCreateWithoutExposureInput = {
    id?: string
    subscriptionId: string
    userId: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertCreateOrConnectWithoutExposureInput = {
    where: AlertWhereUniqueInput
    create: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput>
  }

  export type AlertCreateManyExposureInputEnvelope = {
    data: AlertCreateManyExposureInput | AlertCreateManyExposureInput[]
    skipDuplicates?: boolean
  }

  export type SubscriptionUpsertWithoutExposuresInput = {
    update: XOR<SubscriptionUpdateWithoutExposuresInput, SubscriptionUncheckedUpdateWithoutExposuresInput>
    create: XOR<SubscriptionCreateWithoutExposuresInput, SubscriptionUncheckedCreateWithoutExposuresInput>
    where?: SubscriptionWhereInput
  }

  export type SubscriptionUpdateToOneWithWhereWithoutExposuresInput = {
    where?: SubscriptionWhereInput
    data: XOR<SubscriptionUpdateWithoutExposuresInput, SubscriptionUncheckedUpdateWithoutExposuresInput>
  }

  export type SubscriptionUpdateWithoutExposuresInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
    familyGroup?: FamilyGroupUpdateOneWithoutSubscriptionsNestedInput
    watchlistItems?: WatchlistItemUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateWithoutExposuresInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItems?: WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type WatchlistItemUpsertWithoutExposuresInput = {
    update: XOR<WatchlistItemUpdateWithoutExposuresInput, WatchlistItemUncheckedUpdateWithoutExposuresInput>
    create: XOR<WatchlistItemCreateWithoutExposuresInput, WatchlistItemUncheckedCreateWithoutExposuresInput>
    where?: WatchlistItemWhereInput
  }

  export type WatchlistItemUpdateToOneWithWhereWithoutExposuresInput = {
    where?: WatchlistItemWhereInput
    data: XOR<WatchlistItemUpdateWithoutExposuresInput, WatchlistItemUncheckedUpdateWithoutExposuresInput>
  }

  export type WatchlistItemUpdateWithoutExposuresInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutWatchlistItemsNestedInput
  }

  export type WatchlistItemUncheckedUpdateWithoutExposuresInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUpsertWithWhereUniqueWithoutExposureInput = {
    where: AlertWhereUniqueInput
    update: XOR<AlertUpdateWithoutExposureInput, AlertUncheckedUpdateWithoutExposureInput>
    create: XOR<AlertCreateWithoutExposureInput, AlertUncheckedCreateWithoutExposureInput>
  }

  export type AlertUpdateWithWhereUniqueWithoutExposureInput = {
    where: AlertWhereUniqueInput
    data: XOR<AlertUpdateWithoutExposureInput, AlertUncheckedUpdateWithoutExposureInput>
  }

  export type AlertUpdateManyWithWhereWithoutExposureInput = {
    where: AlertScalarWhereInput
    data: XOR<AlertUpdateManyMutationInput, AlertUncheckedUpdateManyWithoutExposureInput>
  }

  export type SubscriptionCreateWithoutAlertsInput = {
    id?: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
    familyGroup?: FamilyGroupCreateNestedOneWithoutSubscriptionsInput
    watchlistItems?: WatchlistItemCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionUncheckedCreateWithoutAlertsInput = {
    id?: string
    userId: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    watchlistItems?: WatchlistItemUncheckedCreateNestedManyWithoutSubscriptionInput
    exposures?: ExposureUncheckedCreateNestedManyWithoutSubscriptionInput
  }

  export type SubscriptionCreateOrConnectWithoutAlertsInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutAlertsInput, SubscriptionUncheckedCreateWithoutAlertsInput>
  }

  export type UserCreateWithoutAlertsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAlertsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAlertsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAlertsInput, UserUncheckedCreateWithoutAlertsInput>
  }

  export type ExposureCreateWithoutAlertsInput = {
    id?: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    subscription: SubscriptionCreateNestedOneWithoutExposuresInput
    watchlistItem?: WatchlistItemCreateNestedOneWithoutExposuresInput
  }

  export type ExposureUncheckedCreateWithoutAlertsInput = {
    id?: string
    subscriptionId: string
    watchlistItemId?: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExposureCreateOrConnectWithoutAlertsInput = {
    where: ExposureWhereUniqueInput
    create: XOR<ExposureCreateWithoutAlertsInput, ExposureUncheckedCreateWithoutAlertsInput>
  }

  export type SubscriptionUpsertWithoutAlertsInput = {
    update: XOR<SubscriptionUpdateWithoutAlertsInput, SubscriptionUncheckedUpdateWithoutAlertsInput>
    create: XOR<SubscriptionCreateWithoutAlertsInput, SubscriptionUncheckedCreateWithoutAlertsInput>
    where?: SubscriptionWhereInput
  }

  export type SubscriptionUpdateToOneWithWhereWithoutAlertsInput = {
    where?: SubscriptionWhereInput
    data: XOR<SubscriptionUpdateWithoutAlertsInput, SubscriptionUncheckedUpdateWithoutAlertsInput>
  }

  export type SubscriptionUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
    familyGroup?: FamilyGroupUpdateOneWithoutSubscriptionsNestedInput
    watchlistItems?: WatchlistItemUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItems?: WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type UserUpsertWithoutAlertsInput = {
    update: XOR<UserUpdateWithoutAlertsInput, UserUncheckedUpdateWithoutAlertsInput>
    create: XOR<UserCreateWithoutAlertsInput, UserUncheckedCreateWithoutAlertsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAlertsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAlertsInput, UserUncheckedUpdateWithoutAlertsInput>
  }

  export type UserUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ExposureUpsertWithoutAlertsInput = {
    update: XOR<ExposureUpdateWithoutAlertsInput, ExposureUncheckedUpdateWithoutAlertsInput>
    create: XOR<ExposureCreateWithoutAlertsInput, ExposureUncheckedCreateWithoutAlertsInput>
    where?: ExposureWhereInput
  }

  export type ExposureUpdateToOneWithWhereWithoutAlertsInput = {
    where?: ExposureWhereInput
    data: XOR<ExposureUpdateWithoutAlertsInput, ExposureUncheckedUpdateWithoutAlertsInput>
  }

  export type ExposureUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutExposuresNestedInput
    watchlistItem?: WatchlistItemUpdateOneWithoutExposuresNestedInput
  }

  export type ExposureUncheckedUpdateWithoutAlertsInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    watchlistItemId?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateWithoutVoiceEnrollmentsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutVoiceEnrollmentsInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutVoiceEnrollmentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutVoiceEnrollmentsInput, UserUncheckedCreateWithoutVoiceEnrollmentsInput>
  }

  export type VoiceAnalysisCreateWithoutEnrollmentInput = {
    id?: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutVoiceAnalysesInput
  }

  export type VoiceAnalysisUncheckedCreateWithoutEnrollmentInput = {
    id?: string
    userId: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type VoiceAnalysisCreateOrConnectWithoutEnrollmentInput = {
    where: VoiceAnalysisWhereUniqueInput
    create: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput>
  }

  export type VoiceAnalysisCreateManyEnrollmentInputEnvelope = {
    data: VoiceAnalysisCreateManyEnrollmentInput | VoiceAnalysisCreateManyEnrollmentInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutVoiceEnrollmentsInput = {
    update: XOR<UserUpdateWithoutVoiceEnrollmentsInput, UserUncheckedUpdateWithoutVoiceEnrollmentsInput>
    create: XOR<UserCreateWithoutVoiceEnrollmentsInput, UserUncheckedCreateWithoutVoiceEnrollmentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutVoiceEnrollmentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutVoiceEnrollmentsInput, UserUncheckedUpdateWithoutVoiceEnrollmentsInput>
  }

  export type UserUpdateWithoutVoiceEnrollmentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutVoiceEnrollmentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type VoiceAnalysisUpsertWithWhereUniqueWithoutEnrollmentInput = {
    where: VoiceAnalysisWhereUniqueInput
    update: XOR<VoiceAnalysisUpdateWithoutEnrollmentInput, VoiceAnalysisUncheckedUpdateWithoutEnrollmentInput>
    create: XOR<VoiceAnalysisCreateWithoutEnrollmentInput, VoiceAnalysisUncheckedCreateWithoutEnrollmentInput>
  }

  export type VoiceAnalysisUpdateWithWhereUniqueWithoutEnrollmentInput = {
    where: VoiceAnalysisWhereUniqueInput
    data: XOR<VoiceAnalysisUpdateWithoutEnrollmentInput, VoiceAnalysisUncheckedUpdateWithoutEnrollmentInput>
  }

  export type VoiceAnalysisUpdateManyWithWhereWithoutEnrollmentInput = {
    where: VoiceAnalysisScalarWhereInput
    data: XOR<VoiceAnalysisUpdateManyMutationInput, VoiceAnalysisUncheckedUpdateManyWithoutEnrollmentInput>
  }

  export type VoiceEnrollmentCreateWithoutAnalysesInput = {
    id?: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutVoiceEnrollmentsInput
  }

  export type VoiceEnrollmentUncheckedCreateWithoutAnalysesInput = {
    id?: string
    userId: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VoiceEnrollmentCreateOrConnectWithoutAnalysesInput = {
    where: VoiceEnrollmentWhereUniqueInput
    create: XOR<VoiceEnrollmentCreateWithoutAnalysesInput, VoiceEnrollmentUncheckedCreateWithoutAnalysesInput>
  }

  export type UserCreateWithoutVoiceAnalysesInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutVoiceAnalysesInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutVoiceAnalysesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutVoiceAnalysesInput, UserUncheckedCreateWithoutVoiceAnalysesInput>
  }

  export type VoiceEnrollmentUpsertWithoutAnalysesInput = {
    update: XOR<VoiceEnrollmentUpdateWithoutAnalysesInput, VoiceEnrollmentUncheckedUpdateWithoutAnalysesInput>
    create: XOR<VoiceEnrollmentCreateWithoutAnalysesInput, VoiceEnrollmentUncheckedCreateWithoutAnalysesInput>
    where?: VoiceEnrollmentWhereInput
  }

  export type VoiceEnrollmentUpdateToOneWithWhereWithoutAnalysesInput = {
    where?: VoiceEnrollmentWhereInput
    data: XOR<VoiceEnrollmentUpdateWithoutAnalysesInput, VoiceEnrollmentUncheckedUpdateWithoutAnalysesInput>
  }

  export type VoiceEnrollmentUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutVoiceEnrollmentsNestedInput
  }

  export type VoiceEnrollmentUncheckedUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUpsertWithoutVoiceAnalysesInput = {
    update: XOR<UserUpdateWithoutVoiceAnalysesInput, UserUncheckedUpdateWithoutVoiceAnalysesInput>
    create: XOR<UserCreateWithoutVoiceAnalysesInput, UserUncheckedCreateWithoutVoiceAnalysesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutVoiceAnalysesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutVoiceAnalysesInput, UserUncheckedUpdateWithoutVoiceAnalysesInput>
  }

  export type UserUpdateWithoutVoiceAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutVoiceAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSpamFeedbackInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSpamFeedbackInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamRules?: SpamRuleUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSpamFeedbackInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSpamFeedbackInput, UserUncheckedCreateWithoutSpamFeedbackInput>
  }

  export type UserUpsertWithoutSpamFeedbackInput = {
    update: XOR<UserUpdateWithoutSpamFeedbackInput, UserUncheckedUpdateWithoutSpamFeedbackInput>
    create: XOR<UserCreateWithoutSpamFeedbackInput, UserUncheckedCreateWithoutSpamFeedbackInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSpamFeedbackInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSpamFeedbackInput, UserUncheckedUpdateWithoutSpamFeedbackInput>
  }

  export type UserUpdateWithoutSpamFeedbackInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSpamFeedbackInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamRules?: SpamRuleUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSpamRulesInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    alerts?: AlertCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSpamRulesInput = {
    id?: string
    email: string
    emailVerified?: Date | string | null
    name?: string | null
    image?: string | null
    role?: $Enums.UserRole
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    familyGroups?: FamilyGroupMemberUncheckedCreateNestedManyWithoutUserInput
    familyGroupOwned?: FamilyGroupUncheckedCreateNestedManyWithoutOwnerInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    alerts?: AlertUncheckedCreateNestedManyWithoutUserInput
    voiceEnrollments?: VoiceEnrollmentUncheckedCreateNestedManyWithoutUserInput
    voiceAnalyses?: VoiceAnalysisUncheckedCreateNestedManyWithoutUserInput
    spamFeedback?: SpamFeedbackUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSpamRulesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSpamRulesInput, UserUncheckedCreateWithoutSpamRulesInput>
  }

  export type UserUpsertWithoutSpamRulesInput = {
    update: XOR<UserUpdateWithoutSpamRulesInput, UserUncheckedUpdateWithoutSpamRulesInput>
    create: XOR<UserCreateWithoutSpamRulesInput, UserUncheckedCreateWithoutSpamRulesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSpamRulesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSpamRulesInput, UserUncheckedUpdateWithoutSpamRulesInput>
  }

  export type UserUpdateWithoutSpamRulesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    alerts?: AlertUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSpamRulesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    familyGroups?: FamilyGroupMemberUncheckedUpdateManyWithoutUserNestedInput
    familyGroupOwned?: FamilyGroupUncheckedUpdateManyWithoutOwnerNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutUserNestedInput
    voiceEnrollments?: VoiceEnrollmentUncheckedUpdateManyWithoutUserNestedInput
    voiceAnalyses?: VoiceAnalysisUncheckedUpdateManyWithoutUserNestedInput
    spamFeedback?: SpamFeedbackUncheckedUpdateManyWithoutUserNestedInput
  }

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

  export type SessionCreateManyUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberCreateManyUserInput = {
    id?: string
    groupId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupCreateManyOwnerInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SubscriptionCreateManyUserInput = {
    id?: string
    familyGroupId?: string | null
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertCreateManyUserInput = {
    id?: string
    subscriptionId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VoiceEnrollmentCreateManyUserInput = {
    id?: string
    name: string
    voiceHash: string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VoiceAnalysisCreateManyUserInput = {
    id?: string
    enrollmentId?: string | null
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type SpamFeedbackCreateManyUserInput = {
    id?: string
    phoneNumber: string
    phoneNumberHash: string
    isSpam: boolean
    confidence?: number | null
    feedbackType: $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SpamRuleCreateManyUserInput = {
    id?: string
    isGlobal?: boolean
    ruleType: $Enums.RuleType
    pattern: string
    action: $Enums.RuleAction
    priority?: number
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    group?: FamilyGroupUpdateOneRequiredWithoutMembersNestedInput
  }

  export type FamilyGroupMemberUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupUpdateWithoutOwnerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    members?: FamilyGroupMemberUpdateManyWithoutGroupNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutFamilyGroupNestedInput
  }

  export type FamilyGroupUncheckedUpdateWithoutOwnerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    members?: FamilyGroupMemberUncheckedUpdateManyWithoutGroupNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutFamilyGroupNestedInput
  }

  export type FamilyGroupUncheckedUpdateManyWithoutOwnerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyGroup?: FamilyGroupUpdateOneWithoutSubscriptionsNestedInput
    watchlistItems?: WatchlistItemUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItems?: WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    familyGroupId?: NullableStringFieldUpdateOperationsInput | string | null
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutAlertsNestedInput
    exposure?: ExposureUpdateOneWithoutAlertsNestedInput
  }

  export type AlertUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceEnrollmentUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: VoiceAnalysisUpdateManyWithoutEnrollmentNestedInput
  }

  export type VoiceEnrollmentUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: VoiceAnalysisUncheckedUpdateManyWithoutEnrollmentNestedInput
  }

  export type VoiceEnrollmentUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    voiceHash?: StringFieldUpdateOperationsInput | string
    audioMetadata?: NullableJsonNullValueInput | InputJsonValue
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    enrollment?: VoiceEnrollmentUpdateOneWithoutAnalysesNestedInput
  }

  export type VoiceAnalysisUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    enrollmentId?: NullableStringFieldUpdateOperationsInput | string | null
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    enrollmentId?: NullableStringFieldUpdateOperationsInput | string | null
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamFeedbackUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    phoneNumberHash?: StringFieldUpdateOperationsInput | string
    isSpam?: BoolFieldUpdateOperationsInput | boolean
    confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    feedbackType?: EnumFeedbackTypeFieldUpdateOperationsInput | $Enums.FeedbackType
    metadata?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SpamRuleUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    isGlobal?: BoolFieldUpdateOperationsInput | boolean
    ruleType?: EnumRuleTypeFieldUpdateOperationsInput | $Enums.RuleType
    pattern?: StringFieldUpdateOperationsInput | string
    action?: EnumRuleActionFieldUpdateOperationsInput | $Enums.RuleAction
    priority?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberCreateManyGroupInput = {
    id?: string
    userId: string
    role?: $Enums.FamilyMemberRole
    joinedAt?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SubscriptionCreateManyFamilyGroupInput = {
    id?: string
    userId: string
    stripeId?: string | null
    tier?: $Enums.SubscriptionTier
    status?: $Enums.SubscriptionStatus
    currentPeriodStart: Date | string
    currentPeriodEnd: Date | string
    cancelAtPeriodEnd?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FamilyGroupMemberUpdateWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutFamilyGroupsNestedInput
  }

  export type FamilyGroupMemberUncheckedUpdateWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FamilyGroupMemberUncheckedUpdateManyWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    role?: EnumFamilyMemberRoleFieldUpdateOperationsInput | $Enums.FamilyMemberRole
    joinedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUpdateWithoutFamilyGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
    watchlistItems?: WatchlistItemUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateWithoutFamilyGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItems?: WatchlistItemUncheckedUpdateManyWithoutSubscriptionNestedInput
    exposures?: ExposureUncheckedUpdateManyWithoutSubscriptionNestedInput
    alerts?: AlertUncheckedUpdateManyWithoutSubscriptionNestedInput
  }

  export type SubscriptionUncheckedUpdateManyWithoutFamilyGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    stripeId?: NullableStringFieldUpdateOperationsInput | string | null
    tier?: EnumSubscriptionTierFieldUpdateOperationsInput | $Enums.SubscriptionTier
    status?: EnumSubscriptionStatusFieldUpdateOperationsInput | $Enums.SubscriptionStatus
    currentPeriodStart?: DateTimeFieldUpdateOperationsInput | Date | string
    currentPeriodEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    cancelAtPeriodEnd?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WatchlistItemCreateManySubscriptionInput = {
    id?: string
    type: $Enums.WatchlistType
    value: string
    hash: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExposureCreateManySubscriptionInput = {
    id?: string
    watchlistItemId?: string | null
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertCreateManySubscriptionInput = {
    id?: string
    userId: string
    exposureId?: string | null
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WatchlistItemUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exposures?: ExposureUpdateManyWithoutWatchlistItemNestedInput
  }

  export type WatchlistItemUncheckedUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exposures?: ExposureUncheckedUpdateManyWithoutWatchlistItemNestedInput
  }

  export type WatchlistItemUncheckedUpdateManyWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    value?: StringFieldUpdateOperationsInput | string
    hash?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExposureUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    watchlistItem?: WatchlistItemUpdateOneWithoutExposuresNestedInput
    alerts?: AlertUpdateManyWithoutExposureNestedInput
  }

  export type ExposureUncheckedUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    watchlistItemId?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alerts?: AlertUncheckedUpdateManyWithoutExposureNestedInput
  }

  export type ExposureUncheckedUpdateManyWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    watchlistItemId?: NullableStringFieldUpdateOperationsInput | string | null
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAlertsNestedInput
    exposure?: ExposureUpdateOneWithoutAlertsNestedInput
  }

  export type AlertUncheckedUpdateWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUncheckedUpdateManyWithoutSubscriptionInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    exposureId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExposureCreateManyWatchlistItemInput = {
    id?: string
    subscriptionId: string
    source: $Enums.ExposureSource
    dataType: $Enums.WatchlistType
    identifier: string
    identifierHash: string
    severity?: $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: boolean
    detectedAt: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExposureUpdateWithoutWatchlistItemInput = {
    id?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutExposuresNestedInput
    alerts?: AlertUpdateManyWithoutExposureNestedInput
  }

  export type ExposureUncheckedUpdateWithoutWatchlistItemInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alerts?: AlertUncheckedUpdateManyWithoutExposureNestedInput
  }

  export type ExposureUncheckedUpdateManyWithoutWatchlistItemInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    source?: EnumExposureSourceFieldUpdateOperationsInput | $Enums.ExposureSource
    dataType?: EnumWatchlistTypeFieldUpdateOperationsInput | $Enums.WatchlistType
    identifier?: StringFieldUpdateOperationsInput | string
    identifierHash?: StringFieldUpdateOperationsInput | string
    severity?: EnumExposureSeverityFieldUpdateOperationsInput | $Enums.ExposureSeverity
    metadata?: NullableJsonNullValueInput | InputJsonValue
    isFirstTime?: BoolFieldUpdateOperationsInput | boolean
    detectedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertCreateManyExposureInput = {
    id?: string
    subscriptionId: string
    userId: string
    type: $Enums.AlertType
    title: string
    message: string
    severity?: $Enums.AlertSeverity
    isRead?: boolean
    readAt?: Date | string | null
    channel?: AlertCreatechannelInput | $Enums.AlertChannel[]
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AlertUpdateWithoutExposureInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    subscription?: SubscriptionUpdateOneRequiredWithoutAlertsNestedInput
    user?: UserUpdateOneRequiredWithoutAlertsNestedInput
  }

  export type AlertUncheckedUpdateWithoutExposureInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlertUncheckedUpdateManyWithoutExposureInput = {
    id?: StringFieldUpdateOperationsInput | string
    subscriptionId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    type?: EnumAlertTypeFieldUpdateOperationsInput | $Enums.AlertType
    title?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    severity?: EnumAlertSeverityFieldUpdateOperationsInput | $Enums.AlertSeverity
    isRead?: BoolFieldUpdateOperationsInput | boolean
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    channel?: AlertUpdatechannelInput | $Enums.AlertChannel[]
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisCreateManyEnrollmentInput = {
    id?: string
    userId: string
    audioHash: string
    isSynthetic: boolean
    confidence: number
    analysisResult: JsonNullValueInput | InputJsonValue
    audioUrl: string
    createdAt?: Date | string
  }

  export type VoiceAnalysisUpdateWithoutEnrollmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutVoiceAnalysesNestedInput
  }

  export type VoiceAnalysisUncheckedUpdateWithoutEnrollmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VoiceAnalysisUncheckedUpdateManyWithoutEnrollmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    audioHash?: StringFieldUpdateOperationsInput | string
    isSynthetic?: BoolFieldUpdateOperationsInput | boolean
    confidence?: FloatFieldUpdateOperationsInput | number
    analysisResult?: JsonNullValueInput | InputJsonValue
    audioUrl?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FamilyGroupCountOutputTypeDefaultArgs instead
     */
    export type FamilyGroupCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FamilyGroupCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SubscriptionCountOutputTypeDefaultArgs instead
     */
    export type SubscriptionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SubscriptionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WatchlistItemCountOutputTypeDefaultArgs instead
     */
    export type WatchlistItemCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WatchlistItemCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExposureCountOutputTypeDefaultArgs instead
     */
    export type ExposureCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExposureCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VoiceEnrollmentCountOutputTypeDefaultArgs instead
     */
    export type VoiceEnrollmentCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VoiceEnrollmentCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AccountDefaultArgs instead
     */
    export type AccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AccountDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SessionDefaultArgs instead
     */
    export type SessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FamilyGroupDefaultArgs instead
     */
    export type FamilyGroupArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FamilyGroupDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FamilyGroupMemberDefaultArgs instead
     */
    export type FamilyGroupMemberArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FamilyGroupMemberDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SubscriptionDefaultArgs instead
     */
    export type SubscriptionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SubscriptionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WatchlistItemDefaultArgs instead
     */
    export type WatchlistItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WatchlistItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExposureDefaultArgs instead
     */
    export type ExposureArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExposureDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AlertDefaultArgs instead
     */
    export type AlertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AlertDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VoiceEnrollmentDefaultArgs instead
     */
    export type VoiceEnrollmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VoiceEnrollmentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VoiceAnalysisDefaultArgs instead
     */
    export type VoiceAnalysisArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VoiceAnalysisDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SpamFeedbackDefaultArgs instead
     */
    export type SpamFeedbackArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SpamFeedbackDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SpamRuleDefaultArgs instead
     */
    export type SpamRuleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SpamRuleDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AuditLogDefaultArgs instead
     */
    export type AuditLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AuditLogDefaultArgs<ExtArgs>
    /**
     * @deprecated Use KPISnapshotDefaultArgs instead
     */
    export type KPISnapshotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = KPISnapshotDefaultArgs<ExtArgs>

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

  export type BatchPayload = {
    count: number
  }

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