simple-mail-cleaner/backend/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 Tenant
 * 
 */
export type Tenant = $Result.DefaultSelection<Prisma.$TenantPayload>
/**
 * Model ExportJob
 * 
 */
export type ExportJob = $Result.DefaultSelection<Prisma.$ExportJobPayload>
/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model MailboxAccount
 * 
 */
export type MailboxAccount = $Result.DefaultSelection<Prisma.$MailboxAccountPayload>
/**
 * Model MailboxFolder
 * 
 */
export type MailboxFolder = $Result.DefaultSelection<Prisma.$MailboxFolderPayload>
/**
 * Model MailItem
 * 
 */
export type MailItem = $Result.DefaultSelection<Prisma.$MailItemPayload>
/**
 * Model Rule
 * 
 */
export type Rule = $Result.DefaultSelection<Prisma.$RulePayload>
/**
 * Model RuleCondition
 * 
 */
export type RuleCondition = $Result.DefaultSelection<Prisma.$RuleConditionPayload>
/**
 * Model RuleAction
 * 
 */
export type RuleAction = $Result.DefaultSelection<Prisma.$RuleActionPayload>
/**
 * Model CleanupJob
 * 
 */
export type CleanupJob = $Result.DefaultSelection<Prisma.$CleanupJobPayload>
/**
 * Model UnsubscribeAttempt
 * 
 */
export type UnsubscribeAttempt = $Result.DefaultSelection<Prisma.$UnsubscribeAttemptPayload>
/**
 * Model CleanupJobEvent
 * 
 */
export type CleanupJobEvent = $Result.DefaultSelection<Prisma.$CleanupJobEventPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const ExportStatus: {
  QUEUED: 'QUEUED',
  RUNNING: 'RUNNING',
  DONE: 'DONE',
  FAILED: 'FAILED'
};

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


export const UserRole: {
  USER: 'USER',
  ADMIN: 'ADMIN'
};

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


export const MailProvider: {
  GMAIL: 'GMAIL',
  GMX: 'GMX',
  WEBDE: 'WEBDE'
};

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


export const RuleConditionType: {
  HEADER: 'HEADER',
  SUBJECT: 'SUBJECT',
  FROM: 'FROM',
  LIST_UNSUBSCRIBE: 'LIST_UNSUBSCRIBE',
  LIST_ID: 'LIST_ID'
};

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


export const RuleActionType: {
  MOVE: 'MOVE',
  DELETE: 'DELETE',
  ARCHIVE: 'ARCHIVE',
  LABEL: 'LABEL'
};

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


export const JobStatus: {
  QUEUED: 'QUEUED',
  RUNNING: 'RUNNING',
  SUCCEEDED: 'SUCCEEDED',
  FAILED: 'FAILED',
  CANCELED: 'CANCELED'
};

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

}

export type ExportStatus = $Enums.ExportStatus

export const ExportStatus: typeof $Enums.ExportStatus

export type UserRole = $Enums.UserRole

export const UserRole: typeof $Enums.UserRole

export type MailProvider = $Enums.MailProvider

export const MailProvider: typeof $Enums.MailProvider

export type RuleConditionType = $Enums.RuleConditionType

export const RuleConditionType: typeof $Enums.RuleConditionType

export type RuleActionType = $Enums.RuleActionType

export const RuleActionType: typeof $Enums.RuleActionType

export type JobStatus = $Enums.JobStatus

export const JobStatus: typeof $Enums.JobStatus

/**
 * ##  Prisma Client ʲˢ
 * 
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Tenants
 * const tenants = await prisma.tenant.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 Tenants
   * const tenants = await prisma.tenant.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.tenant`: Exposes CRUD operations for the **Tenant** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Tenants
    * const tenants = await prisma.tenant.findMany()
    * ```
    */
  get tenant(): Prisma.TenantDelegate<ExtArgs>;

  /**
   * `prisma.exportJob`: Exposes CRUD operations for the **ExportJob** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExportJobs
    * const exportJobs = await prisma.exportJob.findMany()
    * ```
    */
  get exportJob(): Prisma.ExportJobDelegate<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.mailboxAccount`: Exposes CRUD operations for the **MailboxAccount** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MailboxAccounts
    * const mailboxAccounts = await prisma.mailboxAccount.findMany()
    * ```
    */
  get mailboxAccount(): Prisma.MailboxAccountDelegate<ExtArgs>;

  /**
   * `prisma.mailboxFolder`: Exposes CRUD operations for the **MailboxFolder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MailboxFolders
    * const mailboxFolders = await prisma.mailboxFolder.findMany()
    * ```
    */
  get mailboxFolder(): Prisma.MailboxFolderDelegate<ExtArgs>;

  /**
   * `prisma.mailItem`: Exposes CRUD operations for the **MailItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MailItems
    * const mailItems = await prisma.mailItem.findMany()
    * ```
    */
  get mailItem(): Prisma.MailItemDelegate<ExtArgs>;

  /**
   * `prisma.rule`: Exposes CRUD operations for the **Rule** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Rules
    * const rules = await prisma.rule.findMany()
    * ```
    */
  get rule(): Prisma.RuleDelegate<ExtArgs>;

  /**
   * `prisma.ruleCondition`: Exposes CRUD operations for the **RuleCondition** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more RuleConditions
    * const ruleConditions = await prisma.ruleCondition.findMany()
    * ```
    */
  get ruleCondition(): Prisma.RuleConditionDelegate<ExtArgs>;

  /**
   * `prisma.ruleAction`: Exposes CRUD operations for the **RuleAction** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more RuleActions
    * const ruleActions = await prisma.ruleAction.findMany()
    * ```
    */
  get ruleAction(): Prisma.RuleActionDelegate<ExtArgs>;

  /**
   * `prisma.cleanupJob`: Exposes CRUD operations for the **CleanupJob** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CleanupJobs
    * const cleanupJobs = await prisma.cleanupJob.findMany()
    * ```
    */
  get cleanupJob(): Prisma.CleanupJobDelegate<ExtArgs>;

  /**
   * `prisma.unsubscribeAttempt`: Exposes CRUD operations for the **UnsubscribeAttempt** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UnsubscribeAttempts
    * const unsubscribeAttempts = await prisma.unsubscribeAttempt.findMany()
    * ```
    */
  get unsubscribeAttempt(): Prisma.UnsubscribeAttemptDelegate<ExtArgs>;

  /**
   * `prisma.cleanupJobEvent`: Exposes CRUD operations for the **CleanupJobEvent** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CleanupJobEvents
    * const cleanupJobEvents = await prisma.cleanupJobEvent.findMany()
    * ```
    */
  get cleanupJobEvent(): Prisma.CleanupJobEventDelegate<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: {
    Tenant: 'Tenant',
    ExportJob: 'ExportJob',
    User: 'User',
    MailboxAccount: 'MailboxAccount',
    MailboxFolder: 'MailboxFolder',
    MailItem: 'MailItem',
    Rule: 'Rule',
    RuleCondition: 'RuleCondition',
    RuleAction: 'RuleAction',
    CleanupJob: 'CleanupJob',
    UnsubscribeAttempt: 'UnsubscribeAttempt',
    CleanupJobEvent: 'CleanupJobEvent'
  };

  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: "tenant" | "exportJob" | "user" | "mailboxAccount" | "mailboxFolder" | "mailItem" | "rule" | "ruleCondition" | "ruleAction" | "cleanupJob" | "unsubscribeAttempt" | "cleanupJobEvent"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Tenant: {
        payload: Prisma.$TenantPayload<ExtArgs>
        fields: Prisma.TenantFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TenantFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TenantFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          findFirst: {
            args: Prisma.TenantFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TenantFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          findMany: {
            args: Prisma.TenantFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>[]
          }
          create: {
            args: Prisma.TenantCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          createMany: {
            args: Prisma.TenantCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TenantCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>[]
          }
          delete: {
            args: Prisma.TenantDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          update: {
            args: Prisma.TenantUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          deleteMany: {
            args: Prisma.TenantDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TenantUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TenantUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TenantPayload>
          }
          aggregate: {
            args: Prisma.TenantAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTenant>
          }
          groupBy: {
            args: Prisma.TenantGroupByArgs<ExtArgs>
            result: $Utils.Optional<TenantGroupByOutputType>[]
          }
          count: {
            args: Prisma.TenantCountArgs<ExtArgs>
            result: $Utils.Optional<TenantCountAggregateOutputType> | number
          }
        }
      }
      ExportJob: {
        payload: Prisma.$ExportJobPayload<ExtArgs>
        fields: Prisma.ExportJobFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExportJobFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExportJobFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          findFirst: {
            args: Prisma.ExportJobFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExportJobFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          findMany: {
            args: Prisma.ExportJobFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>[]
          }
          create: {
            args: Prisma.ExportJobCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          createMany: {
            args: Prisma.ExportJobCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExportJobCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>[]
          }
          delete: {
            args: Prisma.ExportJobDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          update: {
            args: Prisma.ExportJobUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          deleteMany: {
            args: Prisma.ExportJobDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExportJobUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExportJobUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExportJobPayload>
          }
          aggregate: {
            args: Prisma.ExportJobAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExportJob>
          }
          groupBy: {
            args: Prisma.ExportJobGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExportJobGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExportJobCountArgs<ExtArgs>
            result: $Utils.Optional<ExportJobCountAggregateOutputType> | number
          }
        }
      }
      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
          }
        }
      }
      MailboxAccount: {
        payload: Prisma.$MailboxAccountPayload<ExtArgs>
        fields: Prisma.MailboxAccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MailboxAccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MailboxAccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          findFirst: {
            args: Prisma.MailboxAccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MailboxAccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          findMany: {
            args: Prisma.MailboxAccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>[]
          }
          create: {
            args: Prisma.MailboxAccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          createMany: {
            args: Prisma.MailboxAccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MailboxAccountCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>[]
          }
          delete: {
            args: Prisma.MailboxAccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          update: {
            args: Prisma.MailboxAccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          deleteMany: {
            args: Prisma.MailboxAccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MailboxAccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MailboxAccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxAccountPayload>
          }
          aggregate: {
            args: Prisma.MailboxAccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMailboxAccount>
          }
          groupBy: {
            args: Prisma.MailboxAccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<MailboxAccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.MailboxAccountCountArgs<ExtArgs>
            result: $Utils.Optional<MailboxAccountCountAggregateOutputType> | number
          }
        }
      }
      MailboxFolder: {
        payload: Prisma.$MailboxFolderPayload<ExtArgs>
        fields: Prisma.MailboxFolderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MailboxFolderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MailboxFolderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          findFirst: {
            args: Prisma.MailboxFolderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MailboxFolderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          findMany: {
            args: Prisma.MailboxFolderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>[]
          }
          create: {
            args: Prisma.MailboxFolderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          createMany: {
            args: Prisma.MailboxFolderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MailboxFolderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>[]
          }
          delete: {
            args: Prisma.MailboxFolderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          update: {
            args: Prisma.MailboxFolderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          deleteMany: {
            args: Prisma.MailboxFolderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MailboxFolderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MailboxFolderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailboxFolderPayload>
          }
          aggregate: {
            args: Prisma.MailboxFolderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMailboxFolder>
          }
          groupBy: {
            args: Prisma.MailboxFolderGroupByArgs<ExtArgs>
            result: $Utils.Optional<MailboxFolderGroupByOutputType>[]
          }
          count: {
            args: Prisma.MailboxFolderCountArgs<ExtArgs>
            result: $Utils.Optional<MailboxFolderCountAggregateOutputType> | number
          }
        }
      }
      MailItem: {
        payload: Prisma.$MailItemPayload<ExtArgs>
        fields: Prisma.MailItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MailItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MailItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          findFirst: {
            args: Prisma.MailItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MailItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          findMany: {
            args: Prisma.MailItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>[]
          }
          create: {
            args: Prisma.MailItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          createMany: {
            args: Prisma.MailItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MailItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>[]
          }
          delete: {
            args: Prisma.MailItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          update: {
            args: Prisma.MailItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          deleteMany: {
            args: Prisma.MailItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MailItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MailItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MailItemPayload>
          }
          aggregate: {
            args: Prisma.MailItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMailItem>
          }
          groupBy: {
            args: Prisma.MailItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<MailItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.MailItemCountArgs<ExtArgs>
            result: $Utils.Optional<MailItemCountAggregateOutputType> | number
          }
        }
      }
      Rule: {
        payload: Prisma.$RulePayload<ExtArgs>
        fields: Prisma.RuleFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RuleFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RuleFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          findFirst: {
            args: Prisma.RuleFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RuleFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          findMany: {
            args: Prisma.RuleFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>[]
          }
          create: {
            args: Prisma.RuleCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          createMany: {
            args: Prisma.RuleCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RuleCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>[]
          }
          delete: {
            args: Prisma.RuleDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          update: {
            args: Prisma.RuleUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          deleteMany: {
            args: Prisma.RuleDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RuleUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.RuleUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RulePayload>
          }
          aggregate: {
            args: Prisma.RuleAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRule>
          }
          groupBy: {
            args: Prisma.RuleGroupByArgs<ExtArgs>
            result: $Utils.Optional<RuleGroupByOutputType>[]
          }
          count: {
            args: Prisma.RuleCountArgs<ExtArgs>
            result: $Utils.Optional<RuleCountAggregateOutputType> | number
          }
        }
      }
      RuleCondition: {
        payload: Prisma.$RuleConditionPayload<ExtArgs>
        fields: Prisma.RuleConditionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RuleConditionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RuleConditionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          findFirst: {
            args: Prisma.RuleConditionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RuleConditionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          findMany: {
            args: Prisma.RuleConditionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>[]
          }
          create: {
            args: Prisma.RuleConditionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          createMany: {
            args: Prisma.RuleConditionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RuleConditionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>[]
          }
          delete: {
            args: Prisma.RuleConditionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          update: {
            args: Prisma.RuleConditionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          deleteMany: {
            args: Prisma.RuleConditionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RuleConditionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.RuleConditionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleConditionPayload>
          }
          aggregate: {
            args: Prisma.RuleConditionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRuleCondition>
          }
          groupBy: {
            args: Prisma.RuleConditionGroupByArgs<ExtArgs>
            result: $Utils.Optional<RuleConditionGroupByOutputType>[]
          }
          count: {
            args: Prisma.RuleConditionCountArgs<ExtArgs>
            result: $Utils.Optional<RuleConditionCountAggregateOutputType> | number
          }
        }
      }
      RuleAction: {
        payload: Prisma.$RuleActionPayload<ExtArgs>
        fields: Prisma.RuleActionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RuleActionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RuleActionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          findFirst: {
            args: Prisma.RuleActionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RuleActionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          findMany: {
            args: Prisma.RuleActionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>[]
          }
          create: {
            args: Prisma.RuleActionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          createMany: {
            args: Prisma.RuleActionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RuleActionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>[]
          }
          delete: {
            args: Prisma.RuleActionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          update: {
            args: Prisma.RuleActionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          deleteMany: {
            args: Prisma.RuleActionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RuleActionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.RuleActionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RuleActionPayload>
          }
          aggregate: {
            args: Prisma.RuleActionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRuleAction>
          }
          groupBy: {
            args: Prisma.RuleActionGroupByArgs<ExtArgs>
            result: $Utils.Optional<RuleActionGroupByOutputType>[]
          }
          count: {
            args: Prisma.RuleActionCountArgs<ExtArgs>
            result: $Utils.Optional<RuleActionCountAggregateOutputType> | number
          }
        }
      }
      CleanupJob: {
        payload: Prisma.$CleanupJobPayload<ExtArgs>
        fields: Prisma.CleanupJobFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CleanupJobFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CleanupJobFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          findFirst: {
            args: Prisma.CleanupJobFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CleanupJobFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          findMany: {
            args: Prisma.CleanupJobFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>[]
          }
          create: {
            args: Prisma.CleanupJobCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          createMany: {
            args: Prisma.CleanupJobCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CleanupJobCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>[]
          }
          delete: {
            args: Prisma.CleanupJobDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          update: {
            args: Prisma.CleanupJobUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          deleteMany: {
            args: Prisma.CleanupJobDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CleanupJobUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CleanupJobUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobPayload>
          }
          aggregate: {
            args: Prisma.CleanupJobAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCleanupJob>
          }
          groupBy: {
            args: Prisma.CleanupJobGroupByArgs<ExtArgs>
            result: $Utils.Optional<CleanupJobGroupByOutputType>[]
          }
          count: {
            args: Prisma.CleanupJobCountArgs<ExtArgs>
            result: $Utils.Optional<CleanupJobCountAggregateOutputType> | number
          }
        }
      }
      UnsubscribeAttempt: {
        payload: Prisma.$UnsubscribeAttemptPayload<ExtArgs>
        fields: Prisma.UnsubscribeAttemptFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UnsubscribeAttemptFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UnsubscribeAttemptFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          findFirst: {
            args: Prisma.UnsubscribeAttemptFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UnsubscribeAttemptFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          findMany: {
            args: Prisma.UnsubscribeAttemptFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>[]
          }
          create: {
            args: Prisma.UnsubscribeAttemptCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          createMany: {
            args: Prisma.UnsubscribeAttemptCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UnsubscribeAttemptCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>[]
          }
          delete: {
            args: Prisma.UnsubscribeAttemptDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          update: {
            args: Prisma.UnsubscribeAttemptUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          deleteMany: {
            args: Prisma.UnsubscribeAttemptDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UnsubscribeAttemptUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UnsubscribeAttemptUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UnsubscribeAttemptPayload>
          }
          aggregate: {
            args: Prisma.UnsubscribeAttemptAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUnsubscribeAttempt>
          }
          groupBy: {
            args: Prisma.UnsubscribeAttemptGroupByArgs<ExtArgs>
            result: $Utils.Optional<UnsubscribeAttemptGroupByOutputType>[]
          }
          count: {
            args: Prisma.UnsubscribeAttemptCountArgs<ExtArgs>
            result: $Utils.Optional<UnsubscribeAttemptCountAggregateOutputType> | number
          }
        }
      }
      CleanupJobEvent: {
        payload: Prisma.$CleanupJobEventPayload<ExtArgs>
        fields: Prisma.CleanupJobEventFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CleanupJobEventFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CleanupJobEventFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          findFirst: {
            args: Prisma.CleanupJobEventFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CleanupJobEventFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          findMany: {
            args: Prisma.CleanupJobEventFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>[]
          }
          create: {
            args: Prisma.CleanupJobEventCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          createMany: {
            args: Prisma.CleanupJobEventCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CleanupJobEventCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>[]
          }
          delete: {
            args: Prisma.CleanupJobEventDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          update: {
            args: Prisma.CleanupJobEventUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          deleteMany: {
            args: Prisma.CleanupJobEventDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CleanupJobEventUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CleanupJobEventUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CleanupJobEventPayload>
          }
          aggregate: {
            args: Prisma.CleanupJobEventAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCleanupJobEvent>
          }
          groupBy: {
            args: Prisma.CleanupJobEventGroupByArgs<ExtArgs>
            result: $Utils.Optional<CleanupJobEventGroupByOutputType>[]
          }
          count: {
            args: Prisma.CleanupJobEventCountArgs<ExtArgs>
            result: $Utils.Optional<CleanupJobEventCountAggregateOutputType> | 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 TenantCountOutputType
   */

  export type TenantCountOutputType = {
    exportJobs: number
    users: number
    mailboxAccounts: number
    rules: number
    jobs: number
  }

  export type TenantCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    exportJobs?: boolean | TenantCountOutputTypeCountExportJobsArgs
    users?: boolean | TenantCountOutputTypeCountUsersArgs
    mailboxAccounts?: boolean | TenantCountOutputTypeCountMailboxAccountsArgs
    rules?: boolean | TenantCountOutputTypeCountRulesArgs
    jobs?: boolean | TenantCountOutputTypeCountJobsArgs
  }

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

  /**
   * TenantCountOutputType without action
   */
  export type TenantCountOutputTypeCountExportJobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExportJobWhereInput
  }

  /**
   * TenantCountOutputType without action
   */
  export type TenantCountOutputTypeCountUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
  }

  /**
   * TenantCountOutputType without action
   */
  export type TenantCountOutputTypeCountMailboxAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailboxAccountWhereInput
  }

  /**
   * TenantCountOutputType without action
   */
  export type TenantCountOutputTypeCountRulesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleWhereInput
  }

  /**
   * TenantCountOutputType without action
   */
  export type TenantCountOutputTypeCountJobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CleanupJobWhereInput
  }


  /**
   * Count Type MailboxAccountCountOutputType
   */

  export type MailboxAccountCountOutputType = {
    folders: number
    jobs: number
  }

  export type MailboxAccountCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    folders?: boolean | MailboxAccountCountOutputTypeCountFoldersArgs
    jobs?: boolean | MailboxAccountCountOutputTypeCountJobsArgs
  }

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

  /**
   * MailboxAccountCountOutputType without action
   */
  export type MailboxAccountCountOutputTypeCountFoldersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailboxFolderWhereInput
  }

  /**
   * MailboxAccountCountOutputType without action
   */
  export type MailboxAccountCountOutputTypeCountJobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CleanupJobWhereInput
  }


  /**
   * Count Type MailboxFolderCountOutputType
   */

  export type MailboxFolderCountOutputType = {
    mailItems: number
  }

  export type MailboxFolderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    mailItems?: boolean | MailboxFolderCountOutputTypeCountMailItemsArgs
  }

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

  /**
   * MailboxFolderCountOutputType without action
   */
  export type MailboxFolderCountOutputTypeCountMailItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailItemWhereInput
  }


  /**
   * Count Type RuleCountOutputType
   */

  export type RuleCountOutputType = {
    conditions: number
    actions: number
  }

  export type RuleCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    conditions?: boolean | RuleCountOutputTypeCountConditionsArgs
    actions?: boolean | RuleCountOutputTypeCountActionsArgs
  }

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

  /**
   * RuleCountOutputType without action
   */
  export type RuleCountOutputTypeCountConditionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleConditionWhereInput
  }

  /**
   * RuleCountOutputType without action
   */
  export type RuleCountOutputTypeCountActionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleActionWhereInput
  }


  /**
   * Count Type CleanupJobCountOutputType
   */

  export type CleanupJobCountOutputType = {
    unsubscribeAttempts: number
    events: number
  }

  export type CleanupJobCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    unsubscribeAttempts?: boolean | CleanupJobCountOutputTypeCountUnsubscribeAttemptsArgs
    events?: boolean | CleanupJobCountOutputTypeCountEventsArgs
  }

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

  /**
   * CleanupJobCountOutputType without action
   */
  export type CleanupJobCountOutputTypeCountUnsubscribeAttemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UnsubscribeAttemptWhereInput
  }

  /**
   * CleanupJobCountOutputType without action
   */
  export type CleanupJobCountOutputTypeCountEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CleanupJobEventWhereInput
  }


  /**
   * Models
   */

  /**
   * Model Tenant
   */

  export type AggregateTenant = {
    _count: TenantCountAggregateOutputType | null
    _min: TenantMinAggregateOutputType | null
    _max: TenantMaxAggregateOutputType | null
  }

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

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

  export type TenantCountAggregateOutputType = {
    id: number
    name: number
    isActive: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type TenantMinAggregateInputType = {
    id?: true
    name?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type TenantMaxAggregateInputType = {
    id?: true
    name?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type TenantCountAggregateInputType = {
    id?: true
    name?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type TenantGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TenantWhereInput
    orderBy?: TenantOrderByWithAggregationInput | TenantOrderByWithAggregationInput[]
    by: TenantScalarFieldEnum[] | TenantScalarFieldEnum
    having?: TenantScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TenantCountAggregateInputType | true
    _min?: TenantMinAggregateInputType
    _max?: TenantMaxAggregateInputType
  }

  export type TenantGroupByOutputType = {
    id: string
    name: string
    isActive: boolean
    createdAt: Date
    updatedAt: Date
    _count: TenantCountAggregateOutputType | null
    _min: TenantMinAggregateOutputType | null
    _max: TenantMaxAggregateOutputType | null
  }

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


  export type TenantSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    exportJobs?: boolean | Tenant$exportJobsArgs<ExtArgs>
    users?: boolean | Tenant$usersArgs<ExtArgs>
    mailboxAccounts?: boolean | Tenant$mailboxAccountsArgs<ExtArgs>
    rules?: boolean | Tenant$rulesArgs<ExtArgs>
    jobs?: boolean | Tenant$jobsArgs<ExtArgs>
    _count?: boolean | TenantCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["tenant"]>

  export type TenantSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["tenant"]>

  export type TenantSelectScalar = {
    id?: boolean
    name?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type TenantInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    exportJobs?: boolean | Tenant$exportJobsArgs<ExtArgs>
    users?: boolean | Tenant$usersArgs<ExtArgs>
    mailboxAccounts?: boolean | Tenant$mailboxAccountsArgs<ExtArgs>
    rules?: boolean | Tenant$rulesArgs<ExtArgs>
    jobs?: boolean | Tenant$jobsArgs<ExtArgs>
    _count?: boolean | TenantCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type TenantIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $TenantPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Tenant"
    objects: {
      exportJobs: Prisma.$ExportJobPayload<ExtArgs>[]
      users: Prisma.$UserPayload<ExtArgs>[]
      mailboxAccounts: Prisma.$MailboxAccountPayload<ExtArgs>[]
      rules: Prisma.$RulePayload<ExtArgs>[]
      jobs: Prisma.$CleanupJobPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      isActive: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["tenant"]>
    composites: {}
  }

  type TenantGetPayload<S extends boolean | null | undefined | TenantDefaultArgs> = $Result.GetResult<Prisma.$TenantPayload, S>

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

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

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

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

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

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

    /**
     * Create a Tenant.
     * @param {TenantCreateArgs} args - Arguments to create a Tenant.
     * @example
     * // Create one Tenant
     * const Tenant = await prisma.tenant.create({
     *   data: {
     *     // ... data to create a Tenant
     *   }
     * })
     * 
     */
    create<T extends TenantCreateArgs>(args: SelectSubset<T, TenantCreateArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Tenant.
     * @param {TenantDeleteArgs} args - Arguments to delete one Tenant.
     * @example
     * // Delete one Tenant
     * const Tenant = await prisma.tenant.delete({
     *   where: {
     *     // ... filter to delete one Tenant
     *   }
     * })
     * 
     */
    delete<T extends TenantDeleteArgs>(args: SelectSubset<T, TenantDeleteArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Tenant.
   * 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__TenantClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    exportJobs<T extends Tenant$exportJobsArgs<ExtArgs> = {}>(args?: Subset<T, Tenant$exportJobsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExportJobPayload<ExtArgs>, T, "findMany"> | Null>
    users<T extends Tenant$usersArgs<ExtArgs> = {}>(args?: Subset<T, Tenant$usersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany"> | Null>
    mailboxAccounts<T extends Tenant$mailboxAccountsArgs<ExtArgs> = {}>(args?: Subset<T, Tenant$mailboxAccountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MailboxAccountPayload<ExtArgs>, T, "findMany"> | Null>
    rules<T extends Tenant$rulesArgs<ExtArgs> = {}>(args?: Subset<T, Tenant$rulesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RulePayload<ExtArgs>, T, "findMany"> | Null>
    jobs<T extends Tenant$jobsArgs<ExtArgs> = {}>(args?: Subset<T, Tenant$jobsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CleanupJobPayload<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 Tenant model
   */ 
  interface TenantFieldRefs {
    readonly id: FieldRef<"Tenant", 'String'>
    readonly name: FieldRef<"Tenant", 'String'>
    readonly isActive: FieldRef<"Tenant", 'Boolean'>
    readonly createdAt: FieldRef<"Tenant", 'DateTime'>
    readonly updatedAt: FieldRef<"Tenant", 'DateTime'>
  }
    

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

  /**
   * Tenant findUniqueOrThrow
   */
  export type TenantFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TenantInclude<ExtArgs> | null
    /**
     * Filter, which Tenant to fetch.
     */
    where: TenantWhereUniqueInput
  }

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

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

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

  /**
   * Tenant create
   */
  export type TenantCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TenantInclude<ExtArgs> | null
    /**
     * The data needed to create a Tenant.
     */
    data: XOR<TenantCreateInput, TenantUncheckedCreateInput>
  }

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

  /**
   * Tenant createManyAndReturn
   */
  export type TenantCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Tenants.
     */
    data: TenantCreateManyInput | TenantCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Tenant update
   */
  export type TenantUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TenantInclude<ExtArgs> | null
    /**
     * The data needed to update a Tenant.
     */
    data: XOR<TenantUpdateInput, TenantUncheckedUpdateInput>
    /**
     * Choose, which Tenant to update.
     */
    where: TenantWhereUniqueInput
  }

  /**
   * Tenant updateMany
   */
  export type TenantUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Tenants.
     */
    data: XOR<TenantUpdateManyMutationInput, TenantUncheckedUpdateManyInput>
    /**
     * Filter which Tenants to update
     */
    where?: TenantWhereInput
  }

  /**
   * Tenant upsert
   */
  export type TenantUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TenantInclude<ExtArgs> | null
    /**
     * The filter to search for the Tenant to update in case it exists.
     */
    where: TenantWhereUniqueInput
    /**
     * In case the Tenant found by the `where` argument doesn't exist, create a new Tenant with this data.
     */
    create: XOR<TenantCreateInput, TenantUncheckedCreateInput>
    /**
     * In case the Tenant was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TenantUpdateInput, TenantUncheckedUpdateInput>
  }

  /**
   * Tenant delete
   */
  export type TenantDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tenant
     */
    select?: TenantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TenantInclude<ExtArgs> | null
    /**
     * Filter which Tenant to delete.
     */
    where: TenantWhereUniqueInput
  }

  /**
   * Tenant deleteMany
   */
  export type TenantDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Tenants to delete
     */
    where?: TenantWhereInput
  }

  /**
   * Tenant.exportJobs
   */
  export type Tenant$exportJobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    where?: ExportJobWhereInput
    orderBy?: ExportJobOrderByWithRelationInput | ExportJobOrderByWithRelationInput[]
    cursor?: ExportJobWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExportJobScalarFieldEnum | ExportJobScalarFieldEnum[]
  }

  /**
   * Tenant.users
   */
  export type Tenant$usersArgs<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
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * Tenant.mailboxAccounts
   */
  export type Tenant$mailboxAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    where?: MailboxAccountWhereInput
    orderBy?: MailboxAccountOrderByWithRelationInput | MailboxAccountOrderByWithRelationInput[]
    cursor?: MailboxAccountWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MailboxAccountScalarFieldEnum | MailboxAccountScalarFieldEnum[]
  }

  /**
   * Tenant.rules
   */
  export type Tenant$rulesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    where?: RuleWhereInput
    orderBy?: RuleOrderByWithRelationInput | RuleOrderByWithRelationInput[]
    cursor?: RuleWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RuleScalarFieldEnum | RuleScalarFieldEnum[]
  }

  /**
   * Tenant.jobs
   */
  export type Tenant$jobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    where?: CleanupJobWhereInput
    orderBy?: CleanupJobOrderByWithRelationInput | CleanupJobOrderByWithRelationInput[]
    cursor?: CleanupJobWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CleanupJobScalarFieldEnum | CleanupJobScalarFieldEnum[]
  }

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


  /**
   * Model ExportJob
   */

  export type AggregateExportJob = {
    _count: ExportJobCountAggregateOutputType | null
    _min: ExportJobMinAggregateOutputType | null
    _max: ExportJobMaxAggregateOutputType | null
  }

  export type ExportJobMinAggregateOutputType = {
    id: string | null
    tenantId: string | null
    status: $Enums.ExportStatus | null
    format: string | null
    scope: string | null
    filePath: string | null
    error: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ExportJobMaxAggregateOutputType = {
    id: string | null
    tenantId: string | null
    status: $Enums.ExportStatus | null
    format: string | null
    scope: string | null
    filePath: string | null
    error: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ExportJobCountAggregateOutputType = {
    id: number
    tenantId: number
    status: number
    format: number
    scope: number
    filePath: number
    error: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type ExportJobMinAggregateInputType = {
    id?: true
    tenantId?: true
    status?: true
    format?: true
    scope?: true
    filePath?: true
    error?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ExportJobMaxAggregateInputType = {
    id?: true
    tenantId?: true
    status?: true
    format?: true
    scope?: true
    filePath?: true
    error?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ExportJobCountAggregateInputType = {
    id?: true
    tenantId?: true
    status?: true
    format?: true
    scope?: true
    filePath?: true
    error?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type ExportJobGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExportJobWhereInput
    orderBy?: ExportJobOrderByWithAggregationInput | ExportJobOrderByWithAggregationInput[]
    by: ExportJobScalarFieldEnum[] | ExportJobScalarFieldEnum
    having?: ExportJobScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExportJobCountAggregateInputType | true
    _min?: ExportJobMinAggregateInputType
    _max?: ExportJobMaxAggregateInputType
  }

  export type ExportJobGroupByOutputType = {
    id: string
    tenantId: string
    status: $Enums.ExportStatus
    format: string
    scope: string
    filePath: string | null
    error: string | null
    createdAt: Date
    updatedAt: Date
    _count: ExportJobCountAggregateOutputType | null
    _min: ExportJobMinAggregateOutputType | null
    _max: ExportJobMaxAggregateOutputType | null
  }

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


  export type ExportJobSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    status?: boolean
    format?: boolean
    scope?: boolean
    filePath?: boolean
    error?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["exportJob"]>

  export type ExportJobSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    status?: boolean
    format?: boolean
    scope?: boolean
    filePath?: boolean
    error?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["exportJob"]>

  export type ExportJobSelectScalar = {
    id?: boolean
    tenantId?: boolean
    status?: boolean
    format?: boolean
    scope?: boolean
    filePath?: boolean
    error?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type ExportJobInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }
  export type ExportJobIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }

  export type $ExportJobPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ExportJob"
    objects: {
      tenant: Prisma.$TenantPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tenantId: string
      status: $Enums.ExportStatus
      format: string
      scope: string
      filePath: string | null
      error: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["exportJob"]>
    composites: {}
  }

  type ExportJobGetPayload<S extends boolean | null | undefined | ExportJobDefaultArgs> = $Result.GetResult<Prisma.$ExportJobPayload, S>

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

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

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

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

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

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

    /**
     * Create a ExportJob.
     * @param {ExportJobCreateArgs} args - Arguments to create a ExportJob.
     * @example
     * // Create one ExportJob
     * const ExportJob = await prisma.exportJob.create({
     *   data: {
     *     // ... data to create a ExportJob
     *   }
     * })
     * 
     */
    create<T extends ExportJobCreateArgs>(args: SelectSubset<T, ExportJobCreateArgs<ExtArgs>>): Prisma__ExportJobClient<$Result.GetResult<Prisma.$ExportJobPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a ExportJob.
     * @param {ExportJobDeleteArgs} args - Arguments to delete one ExportJob.
     * @example
     * // Delete one ExportJob
     * const ExportJob = await prisma.exportJob.delete({
     *   where: {
     *     // ... filter to delete one ExportJob
     *   }
     * })
     * 
     */
    delete<T extends ExportJobDeleteArgs>(args: SelectSubset<T, ExportJobDeleteArgs<ExtArgs>>): Prisma__ExportJobClient<$Result.GetResult<Prisma.$ExportJobPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ExportJob.
   * 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__ExportJobClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    tenant<T extends TenantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TenantDefaultArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<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 ExportJob model
   */ 
  interface ExportJobFieldRefs {
    readonly id: FieldRef<"ExportJob", 'String'>
    readonly tenantId: FieldRef<"ExportJob", 'String'>
    readonly status: FieldRef<"ExportJob", 'ExportStatus'>
    readonly format: FieldRef<"ExportJob", 'String'>
    readonly scope: FieldRef<"ExportJob", 'String'>
    readonly filePath: FieldRef<"ExportJob", 'String'>
    readonly error: FieldRef<"ExportJob", 'String'>
    readonly createdAt: FieldRef<"ExportJob", 'DateTime'>
    readonly updatedAt: FieldRef<"ExportJob", 'DateTime'>
  }
    

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

  /**
   * ExportJob findUniqueOrThrow
   */
  export type ExportJobFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    /**
     * Filter, which ExportJob to fetch.
     */
    where: ExportJobWhereUniqueInput
  }

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

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

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

  /**
   * ExportJob create
   */
  export type ExportJobCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    /**
     * The data needed to create a ExportJob.
     */
    data: XOR<ExportJobCreateInput, ExportJobUncheckedCreateInput>
  }

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

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

  /**
   * ExportJob update
   */
  export type ExportJobUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    /**
     * The data needed to update a ExportJob.
     */
    data: XOR<ExportJobUpdateInput, ExportJobUncheckedUpdateInput>
    /**
     * Choose, which ExportJob to update.
     */
    where: ExportJobWhereUniqueInput
  }

  /**
   * ExportJob updateMany
   */
  export type ExportJobUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ExportJobs.
     */
    data: XOR<ExportJobUpdateManyMutationInput, ExportJobUncheckedUpdateManyInput>
    /**
     * Filter which ExportJobs to update
     */
    where?: ExportJobWhereInput
  }

  /**
   * ExportJob upsert
   */
  export type ExportJobUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    /**
     * The filter to search for the ExportJob to update in case it exists.
     */
    where: ExportJobWhereUniqueInput
    /**
     * In case the ExportJob found by the `where` argument doesn't exist, create a new ExportJob with this data.
     */
    create: XOR<ExportJobCreateInput, ExportJobUncheckedCreateInput>
    /**
     * In case the ExportJob was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExportJobUpdateInput, ExportJobUncheckedUpdateInput>
  }

  /**
   * ExportJob delete
   */
  export type ExportJobDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExportJob
     */
    select?: ExportJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExportJobInclude<ExtArgs> | null
    /**
     * Filter which ExportJob to delete.
     */
    where: ExportJobWhereUniqueInput
  }

  /**
   * ExportJob deleteMany
   */
  export type ExportJobDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExportJobs to delete
     */
    where?: ExportJobWhereInput
  }

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


  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    tenantId: string | null
    email: string | null
    password: string | null
    role: $Enums.UserRole | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    tenantId: string | null
    email: string | null
    password: string | null
    role: $Enums.UserRole | null
    isActive: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    tenantId: number
    email: number
    password: number
    role: number
    isActive: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    password?: true
    role?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    password?: true
    role?: true
    isActive?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    password?: true
    role?: true
    isActive?: 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
    tenantId: string
    email: string
    password: string
    role: $Enums.UserRole
    isActive: boolean
    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
    tenantId?: boolean
    email?: boolean
    password?: boolean
    role?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    email?: boolean
    password?: boolean
    role?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    tenantId?: boolean
    email?: boolean
    password?: boolean
    role?: boolean
    isActive?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      tenant: Prisma.$TenantPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tenantId: string
      email: string
      password: string
      role: $Enums.UserRole
      isActive: boolean
      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"
    tenant<T extends TenantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TenantDefaultArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<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 User model
   */ 
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly tenantId: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly password: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'UserRole'>
    readonly isActive: FieldRef<"User", 'Boolean'>
    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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserIncludeCreateManyAndReturn<ExtArgs> | null
  }

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

  export type AggregateMailboxAccount = {
    _count: MailboxAccountCountAggregateOutputType | null
    _avg: MailboxAccountAvgAggregateOutputType | null
    _sum: MailboxAccountSumAggregateOutputType | null
    _min: MailboxAccountMinAggregateOutputType | null
    _max: MailboxAccountMaxAggregateOutputType | null
  }

  export type MailboxAccountAvgAggregateOutputType = {
    imapPort: number | null
    smtpPort: number | null
  }

  export type MailboxAccountSumAggregateOutputType = {
    imapPort: number | null
    smtpPort: number | null
  }

  export type MailboxAccountMinAggregateOutputType = {
    id: string | null
    tenantId: string | null
    email: string | null
    provider: $Enums.MailProvider | null
    isActive: boolean | null
    imapHost: string | null
    imapPort: number | null
    imapTLS: boolean | null
    smtpHost: string | null
    smtpPort: number | null
    smtpTLS: boolean | null
    oauthToken: string | null
    oauthRefreshToken: string | null
    oauthAccessToken: string | null
    oauthExpiresAt: Date | null
    providerUserId: string | null
    appPassword: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailboxAccountMaxAggregateOutputType = {
    id: string | null
    tenantId: string | null
    email: string | null
    provider: $Enums.MailProvider | null
    isActive: boolean | null
    imapHost: string | null
    imapPort: number | null
    imapTLS: boolean | null
    smtpHost: string | null
    smtpPort: number | null
    smtpTLS: boolean | null
    oauthToken: string | null
    oauthRefreshToken: string | null
    oauthAccessToken: string | null
    oauthExpiresAt: Date | null
    providerUserId: string | null
    appPassword: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailboxAccountCountAggregateOutputType = {
    id: number
    tenantId: number
    email: number
    provider: number
    isActive: number
    imapHost: number
    imapPort: number
    imapTLS: number
    smtpHost: number
    smtpPort: number
    smtpTLS: number
    oauthToken: number
    oauthRefreshToken: number
    oauthAccessToken: number
    oauthExpiresAt: number
    providerUserId: number
    appPassword: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type MailboxAccountAvgAggregateInputType = {
    imapPort?: true
    smtpPort?: true
  }

  export type MailboxAccountSumAggregateInputType = {
    imapPort?: true
    smtpPort?: true
  }

  export type MailboxAccountMinAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    provider?: true
    isActive?: true
    imapHost?: true
    imapPort?: true
    imapTLS?: true
    smtpHost?: true
    smtpPort?: true
    smtpTLS?: true
    oauthToken?: true
    oauthRefreshToken?: true
    oauthAccessToken?: true
    oauthExpiresAt?: true
    providerUserId?: true
    appPassword?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailboxAccountMaxAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    provider?: true
    isActive?: true
    imapHost?: true
    imapPort?: true
    imapTLS?: true
    smtpHost?: true
    smtpPort?: true
    smtpTLS?: true
    oauthToken?: true
    oauthRefreshToken?: true
    oauthAccessToken?: true
    oauthExpiresAt?: true
    providerUserId?: true
    appPassword?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailboxAccountCountAggregateInputType = {
    id?: true
    tenantId?: true
    email?: true
    provider?: true
    isActive?: true
    imapHost?: true
    imapPort?: true
    imapTLS?: true
    smtpHost?: true
    smtpPort?: true
    smtpTLS?: true
    oauthToken?: true
    oauthRefreshToken?: true
    oauthAccessToken?: true
    oauthExpiresAt?: true
    providerUserId?: true
    appPassword?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type MailboxAccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MailboxAccount to aggregate.
     */
    where?: MailboxAccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MailboxAccounts to fetch.
     */
    orderBy?: MailboxAccountOrderByWithRelationInput | MailboxAccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MailboxAccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MailboxAccounts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MailboxAccounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MailboxAccounts
    **/
    _count?: true | MailboxAccountCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MailboxAccountAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MailboxAccountSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MailboxAccountMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MailboxAccountMaxAggregateInputType
  }

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




  export type MailboxAccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailboxAccountWhereInput
    orderBy?: MailboxAccountOrderByWithAggregationInput | MailboxAccountOrderByWithAggregationInput[]
    by: MailboxAccountScalarFieldEnum[] | MailboxAccountScalarFieldEnum
    having?: MailboxAccountScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MailboxAccountCountAggregateInputType | true
    _avg?: MailboxAccountAvgAggregateInputType
    _sum?: MailboxAccountSumAggregateInputType
    _min?: MailboxAccountMinAggregateInputType
    _max?: MailboxAccountMaxAggregateInputType
  }

  export type MailboxAccountGroupByOutputType = {
    id: string
    tenantId: string
    email: string
    provider: $Enums.MailProvider
    isActive: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost: string | null
    smtpPort: number | null
    smtpTLS: boolean | null
    oauthToken: string | null
    oauthRefreshToken: string | null
    oauthAccessToken: string | null
    oauthExpiresAt: Date | null
    providerUserId: string | null
    appPassword: string | null
    createdAt: Date
    updatedAt: Date
    _count: MailboxAccountCountAggregateOutputType | null
    _avg: MailboxAccountAvgAggregateOutputType | null
    _sum: MailboxAccountSumAggregateOutputType | null
    _min: MailboxAccountMinAggregateOutputType | null
    _max: MailboxAccountMaxAggregateOutputType | null
  }

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


  export type MailboxAccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    email?: boolean
    provider?: boolean
    isActive?: boolean
    imapHost?: boolean
    imapPort?: boolean
    imapTLS?: boolean
    smtpHost?: boolean
    smtpPort?: boolean
    smtpTLS?: boolean
    oauthToken?: boolean
    oauthRefreshToken?: boolean
    oauthAccessToken?: boolean
    oauthExpiresAt?: boolean
    providerUserId?: boolean
    appPassword?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    folders?: boolean | MailboxAccount$foldersArgs<ExtArgs>
    jobs?: boolean | MailboxAccount$jobsArgs<ExtArgs>
    _count?: boolean | MailboxAccountCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailboxAccount"]>

  export type MailboxAccountSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    email?: boolean
    provider?: boolean
    isActive?: boolean
    imapHost?: boolean
    imapPort?: boolean
    imapTLS?: boolean
    smtpHost?: boolean
    smtpPort?: boolean
    smtpTLS?: boolean
    oauthToken?: boolean
    oauthRefreshToken?: boolean
    oauthAccessToken?: boolean
    oauthExpiresAt?: boolean
    providerUserId?: boolean
    appPassword?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailboxAccount"]>

  export type MailboxAccountSelectScalar = {
    id?: boolean
    tenantId?: boolean
    email?: boolean
    provider?: boolean
    isActive?: boolean
    imapHost?: boolean
    imapPort?: boolean
    imapTLS?: boolean
    smtpHost?: boolean
    smtpPort?: boolean
    smtpTLS?: boolean
    oauthToken?: boolean
    oauthRefreshToken?: boolean
    oauthAccessToken?: boolean
    oauthExpiresAt?: boolean
    providerUserId?: boolean
    appPassword?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type MailboxAccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    folders?: boolean | MailboxAccount$foldersArgs<ExtArgs>
    jobs?: boolean | MailboxAccount$jobsArgs<ExtArgs>
    _count?: boolean | MailboxAccountCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type MailboxAccountIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }

  export type $MailboxAccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MailboxAccount"
    objects: {
      tenant: Prisma.$TenantPayload<ExtArgs>
      folders: Prisma.$MailboxFolderPayload<ExtArgs>[]
      jobs: Prisma.$CleanupJobPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tenantId: string
      email: string
      provider: $Enums.MailProvider
      isActive: boolean
      imapHost: string
      imapPort: number
      imapTLS: boolean
      smtpHost: string | null
      smtpPort: number | null
      smtpTLS: boolean | null
      oauthToken: string | null
      oauthRefreshToken: string | null
      oauthAccessToken: string | null
      oauthExpiresAt: Date | null
      providerUserId: string | null
      appPassword: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["mailboxAccount"]>
    composites: {}
  }

  type MailboxAccountGetPayload<S extends boolean | null | undefined | MailboxAccountDefaultArgs> = $Result.GetResult<Prisma.$MailboxAccountPayload, S>

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

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

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

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

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

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

    /**
     * Create a MailboxAccount.
     * @param {MailboxAccountCreateArgs} args - Arguments to create a MailboxAccount.
     * @example
     * // Create one MailboxAccount
     * const MailboxAccount = await prisma.mailboxAccount.create({
     *   data: {
     *     // ... data to create a MailboxAccount
     *   }
     * })
     * 
     */
    create<T extends MailboxAccountCreateArgs>(args: SelectSubset<T, MailboxAccountCreateArgs<ExtArgs>>): Prisma__MailboxAccountClient<$Result.GetResult<Prisma.$MailboxAccountPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a MailboxAccount.
     * @param {MailboxAccountDeleteArgs} args - Arguments to delete one MailboxAccount.
     * @example
     * // Delete one MailboxAccount
     * const MailboxAccount = await prisma.mailboxAccount.delete({
     *   where: {
     *     // ... filter to delete one MailboxAccount
     *   }
     * })
     * 
     */
    delete<T extends MailboxAccountDeleteArgs>(args: SelectSubset<T, MailboxAccountDeleteArgs<ExtArgs>>): Prisma__MailboxAccountClient<$Result.GetResult<Prisma.$MailboxAccountPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for MailboxAccount.
   * 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__MailboxAccountClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    tenant<T extends TenantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TenantDefaultArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    folders<T extends MailboxAccount$foldersArgs<ExtArgs> = {}>(args?: Subset<T, MailboxAccount$foldersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MailboxFolderPayload<ExtArgs>, T, "findMany"> | Null>
    jobs<T extends MailboxAccount$jobsArgs<ExtArgs> = {}>(args?: Subset<T, MailboxAccount$jobsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CleanupJobPayload<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 MailboxAccount model
   */ 
  interface MailboxAccountFieldRefs {
    readonly id: FieldRef<"MailboxAccount", 'String'>
    readonly tenantId: FieldRef<"MailboxAccount", 'String'>
    readonly email: FieldRef<"MailboxAccount", 'String'>
    readonly provider: FieldRef<"MailboxAccount", 'MailProvider'>
    readonly isActive: FieldRef<"MailboxAccount", 'Boolean'>
    readonly imapHost: FieldRef<"MailboxAccount", 'String'>
    readonly imapPort: FieldRef<"MailboxAccount", 'Int'>
    readonly imapTLS: FieldRef<"MailboxAccount", 'Boolean'>
    readonly smtpHost: FieldRef<"MailboxAccount", 'String'>
    readonly smtpPort: FieldRef<"MailboxAccount", 'Int'>
    readonly smtpTLS: FieldRef<"MailboxAccount", 'Boolean'>
    readonly oauthToken: FieldRef<"MailboxAccount", 'String'>
    readonly oauthRefreshToken: FieldRef<"MailboxAccount", 'String'>
    readonly oauthAccessToken: FieldRef<"MailboxAccount", 'String'>
    readonly oauthExpiresAt: FieldRef<"MailboxAccount", 'DateTime'>
    readonly providerUserId: FieldRef<"MailboxAccount", 'String'>
    readonly appPassword: FieldRef<"MailboxAccount", 'String'>
    readonly createdAt: FieldRef<"MailboxAccount", 'DateTime'>
    readonly updatedAt: FieldRef<"MailboxAccount", 'DateTime'>
  }
    

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

  /**
   * MailboxAccount findUniqueOrThrow
   */
  export type MailboxAccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    /**
     * Filter, which MailboxAccount to fetch.
     */
    where: MailboxAccountWhereUniqueInput
  }

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

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

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

  /**
   * MailboxAccount create
   */
  export type MailboxAccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    /**
     * The data needed to create a MailboxAccount.
     */
    data: XOR<MailboxAccountCreateInput, MailboxAccountUncheckedCreateInput>
  }

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

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

  /**
   * MailboxAccount update
   */
  export type MailboxAccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    /**
     * The data needed to update a MailboxAccount.
     */
    data: XOR<MailboxAccountUpdateInput, MailboxAccountUncheckedUpdateInput>
    /**
     * Choose, which MailboxAccount to update.
     */
    where: MailboxAccountWhereUniqueInput
  }

  /**
   * MailboxAccount updateMany
   */
  export type MailboxAccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MailboxAccounts.
     */
    data: XOR<MailboxAccountUpdateManyMutationInput, MailboxAccountUncheckedUpdateManyInput>
    /**
     * Filter which MailboxAccounts to update
     */
    where?: MailboxAccountWhereInput
  }

  /**
   * MailboxAccount upsert
   */
  export type MailboxAccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    /**
     * The filter to search for the MailboxAccount to update in case it exists.
     */
    where: MailboxAccountWhereUniqueInput
    /**
     * In case the MailboxAccount found by the `where` argument doesn't exist, create a new MailboxAccount with this data.
     */
    create: XOR<MailboxAccountCreateInput, MailboxAccountUncheckedCreateInput>
    /**
     * In case the MailboxAccount was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MailboxAccountUpdateInput, MailboxAccountUncheckedUpdateInput>
  }

  /**
   * MailboxAccount delete
   */
  export type MailboxAccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxAccount
     */
    select?: MailboxAccountSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxAccountInclude<ExtArgs> | null
    /**
     * Filter which MailboxAccount to delete.
     */
    where: MailboxAccountWhereUniqueInput
  }

  /**
   * MailboxAccount deleteMany
   */
  export type MailboxAccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MailboxAccounts to delete
     */
    where?: MailboxAccountWhereInput
  }

  /**
   * MailboxAccount.folders
   */
  export type MailboxAccount$foldersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    where?: MailboxFolderWhereInput
    orderBy?: MailboxFolderOrderByWithRelationInput | MailboxFolderOrderByWithRelationInput[]
    cursor?: MailboxFolderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MailboxFolderScalarFieldEnum | MailboxFolderScalarFieldEnum[]
  }

  /**
   * MailboxAccount.jobs
   */
  export type MailboxAccount$jobsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    where?: CleanupJobWhereInput
    orderBy?: CleanupJobOrderByWithRelationInput | CleanupJobOrderByWithRelationInput[]
    cursor?: CleanupJobWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CleanupJobScalarFieldEnum | CleanupJobScalarFieldEnum[]
  }

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


  /**
   * Model MailboxFolder
   */

  export type AggregateMailboxFolder = {
    _count: MailboxFolderCountAggregateOutputType | null
    _min: MailboxFolderMinAggregateOutputType | null
    _max: MailboxFolderMaxAggregateOutputType | null
  }

  export type MailboxFolderMinAggregateOutputType = {
    id: string | null
    mailboxAccountId: string | null
    name: string | null
    remoteId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailboxFolderMaxAggregateOutputType = {
    id: string | null
    mailboxAccountId: string | null
    name: string | null
    remoteId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailboxFolderCountAggregateOutputType = {
    id: number
    mailboxAccountId: number
    name: number
    remoteId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type MailboxFolderMinAggregateInputType = {
    id?: true
    mailboxAccountId?: true
    name?: true
    remoteId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailboxFolderMaxAggregateInputType = {
    id?: true
    mailboxAccountId?: true
    name?: true
    remoteId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailboxFolderCountAggregateInputType = {
    id?: true
    mailboxAccountId?: true
    name?: true
    remoteId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type MailboxFolderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailboxFolderWhereInput
    orderBy?: MailboxFolderOrderByWithAggregationInput | MailboxFolderOrderByWithAggregationInput[]
    by: MailboxFolderScalarFieldEnum[] | MailboxFolderScalarFieldEnum
    having?: MailboxFolderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MailboxFolderCountAggregateInputType | true
    _min?: MailboxFolderMinAggregateInputType
    _max?: MailboxFolderMaxAggregateInputType
  }

  export type MailboxFolderGroupByOutputType = {
    id: string
    mailboxAccountId: string
    name: string
    remoteId: string | null
    createdAt: Date
    updatedAt: Date
    _count: MailboxFolderCountAggregateOutputType | null
    _min: MailboxFolderMinAggregateOutputType | null
    _max: MailboxFolderMaxAggregateOutputType | null
  }

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


  export type MailboxFolderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    mailboxAccountId?: boolean
    name?: boolean
    remoteId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
    mailItems?: boolean | MailboxFolder$mailItemsArgs<ExtArgs>
    _count?: boolean | MailboxFolderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailboxFolder"]>

  export type MailboxFolderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    mailboxAccountId?: boolean
    name?: boolean
    remoteId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailboxFolder"]>

  export type MailboxFolderSelectScalar = {
    id?: boolean
    mailboxAccountId?: boolean
    name?: boolean
    remoteId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type MailboxFolderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
    mailItems?: boolean | MailboxFolder$mailItemsArgs<ExtArgs>
    _count?: boolean | MailboxFolderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type MailboxFolderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
  }

  export type $MailboxFolderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MailboxFolder"
    objects: {
      mailboxAccount: Prisma.$MailboxAccountPayload<ExtArgs>
      mailItems: Prisma.$MailItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      mailboxAccountId: string
      name: string
      remoteId: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["mailboxFolder"]>
    composites: {}
  }

  type MailboxFolderGetPayload<S extends boolean | null | undefined | MailboxFolderDefaultArgs> = $Result.GetResult<Prisma.$MailboxFolderPayload, S>

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

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

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

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

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

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

    /**
     * Create a MailboxFolder.
     * @param {MailboxFolderCreateArgs} args - Arguments to create a MailboxFolder.
     * @example
     * // Create one MailboxFolder
     * const MailboxFolder = await prisma.mailboxFolder.create({
     *   data: {
     *     // ... data to create a MailboxFolder
     *   }
     * })
     * 
     */
    create<T extends MailboxFolderCreateArgs>(args: SelectSubset<T, MailboxFolderCreateArgs<ExtArgs>>): Prisma__MailboxFolderClient<$Result.GetResult<Prisma.$MailboxFolderPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a MailboxFolder.
     * @param {MailboxFolderDeleteArgs} args - Arguments to delete one MailboxFolder.
     * @example
     * // Delete one MailboxFolder
     * const MailboxFolder = await prisma.mailboxFolder.delete({
     *   where: {
     *     // ... filter to delete one MailboxFolder
     *   }
     * })
     * 
     */
    delete<T extends MailboxFolderDeleteArgs>(args: SelectSubset<T, MailboxFolderDeleteArgs<ExtArgs>>): Prisma__MailboxFolderClient<$Result.GetResult<Prisma.$MailboxFolderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for MailboxFolder.
   * 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__MailboxFolderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    mailboxAccount<T extends MailboxAccountDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MailboxAccountDefaultArgs<ExtArgs>>): Prisma__MailboxAccountClient<$Result.GetResult<Prisma.$MailboxAccountPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    mailItems<T extends MailboxFolder$mailItemsArgs<ExtArgs> = {}>(args?: Subset<T, MailboxFolder$mailItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MailItemPayload<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 MailboxFolder model
   */ 
  interface MailboxFolderFieldRefs {
    readonly id: FieldRef<"MailboxFolder", 'String'>
    readonly mailboxAccountId: FieldRef<"MailboxFolder", 'String'>
    readonly name: FieldRef<"MailboxFolder", 'String'>
    readonly remoteId: FieldRef<"MailboxFolder", 'String'>
    readonly createdAt: FieldRef<"MailboxFolder", 'DateTime'>
    readonly updatedAt: FieldRef<"MailboxFolder", 'DateTime'>
  }
    

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

  /**
   * MailboxFolder findUniqueOrThrow
   */
  export type MailboxFolderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    /**
     * Filter, which MailboxFolder to fetch.
     */
    where: MailboxFolderWhereUniqueInput
  }

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

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

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

  /**
   * MailboxFolder create
   */
  export type MailboxFolderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    /**
     * The data needed to create a MailboxFolder.
     */
    data: XOR<MailboxFolderCreateInput, MailboxFolderUncheckedCreateInput>
  }

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

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

  /**
   * MailboxFolder update
   */
  export type MailboxFolderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    /**
     * The data needed to update a MailboxFolder.
     */
    data: XOR<MailboxFolderUpdateInput, MailboxFolderUncheckedUpdateInput>
    /**
     * Choose, which MailboxFolder to update.
     */
    where: MailboxFolderWhereUniqueInput
  }

  /**
   * MailboxFolder updateMany
   */
  export type MailboxFolderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MailboxFolders.
     */
    data: XOR<MailboxFolderUpdateManyMutationInput, MailboxFolderUncheckedUpdateManyInput>
    /**
     * Filter which MailboxFolders to update
     */
    where?: MailboxFolderWhereInput
  }

  /**
   * MailboxFolder upsert
   */
  export type MailboxFolderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    /**
     * The filter to search for the MailboxFolder to update in case it exists.
     */
    where: MailboxFolderWhereUniqueInput
    /**
     * In case the MailboxFolder found by the `where` argument doesn't exist, create a new MailboxFolder with this data.
     */
    create: XOR<MailboxFolderCreateInput, MailboxFolderUncheckedCreateInput>
    /**
     * In case the MailboxFolder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MailboxFolderUpdateInput, MailboxFolderUncheckedUpdateInput>
  }

  /**
   * MailboxFolder delete
   */
  export type MailboxFolderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailboxFolder
     */
    select?: MailboxFolderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailboxFolderInclude<ExtArgs> | null
    /**
     * Filter which MailboxFolder to delete.
     */
    where: MailboxFolderWhereUniqueInput
  }

  /**
   * MailboxFolder deleteMany
   */
  export type MailboxFolderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MailboxFolders to delete
     */
    where?: MailboxFolderWhereInput
  }

  /**
   * MailboxFolder.mailItems
   */
  export type MailboxFolder$mailItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    where?: MailItemWhereInput
    orderBy?: MailItemOrderByWithRelationInput | MailItemOrderByWithRelationInput[]
    cursor?: MailItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MailItemScalarFieldEnum | MailItemScalarFieldEnum[]
  }

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


  /**
   * Model MailItem
   */

  export type AggregateMailItem = {
    _count: MailItemCountAggregateOutputType | null
    _min: MailItemMinAggregateOutputType | null
    _max: MailItemMaxAggregateOutputType | null
  }

  export type MailItemMinAggregateOutputType = {
    id: string | null
    folderId: string | null
    messageId: string | null
    subject: string | null
    from: string | null
    receivedAt: Date | null
    listId: string | null
    listUnsubscribe: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailItemMaxAggregateOutputType = {
    id: string | null
    folderId: string | null
    messageId: string | null
    subject: string | null
    from: string | null
    receivedAt: Date | null
    listId: string | null
    listUnsubscribe: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type MailItemCountAggregateOutputType = {
    id: number
    folderId: number
    messageId: number
    subject: number
    from: number
    receivedAt: number
    listId: number
    listUnsubscribe: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type MailItemMinAggregateInputType = {
    id?: true
    folderId?: true
    messageId?: true
    subject?: true
    from?: true
    receivedAt?: true
    listId?: true
    listUnsubscribe?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailItemMaxAggregateInputType = {
    id?: true
    folderId?: true
    messageId?: true
    subject?: true
    from?: true
    receivedAt?: true
    listId?: true
    listUnsubscribe?: true
    createdAt?: true
    updatedAt?: true
  }

  export type MailItemCountAggregateInputType = {
    id?: true
    folderId?: true
    messageId?: true
    subject?: true
    from?: true
    receivedAt?: true
    listId?: true
    listUnsubscribe?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type MailItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MailItemWhereInput
    orderBy?: MailItemOrderByWithAggregationInput | MailItemOrderByWithAggregationInput[]
    by: MailItemScalarFieldEnum[] | MailItemScalarFieldEnum
    having?: MailItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MailItemCountAggregateInputType | true
    _min?: MailItemMinAggregateInputType
    _max?: MailItemMaxAggregateInputType
  }

  export type MailItemGroupByOutputType = {
    id: string
    folderId: string
    messageId: string
    subject: string | null
    from: string | null
    receivedAt: Date | null
    listId: string | null
    listUnsubscribe: string | null
    createdAt: Date
    updatedAt: Date
    _count: MailItemCountAggregateOutputType | null
    _min: MailItemMinAggregateOutputType | null
    _max: MailItemMaxAggregateOutputType | null
  }

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


  export type MailItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    folderId?: boolean
    messageId?: boolean
    subject?: boolean
    from?: boolean
    receivedAt?: boolean
    listId?: boolean
    listUnsubscribe?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    folder?: boolean | MailboxFolderDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailItem"]>

  export type MailItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    folderId?: boolean
    messageId?: boolean
    subject?: boolean
    from?: boolean
    receivedAt?: boolean
    listId?: boolean
    listUnsubscribe?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    folder?: boolean | MailboxFolderDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mailItem"]>

  export type MailItemSelectScalar = {
    id?: boolean
    folderId?: boolean
    messageId?: boolean
    subject?: boolean
    from?: boolean
    receivedAt?: boolean
    listId?: boolean
    listUnsubscribe?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type MailItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    folder?: boolean | MailboxFolderDefaultArgs<ExtArgs>
  }
  export type MailItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    folder?: boolean | MailboxFolderDefaultArgs<ExtArgs>
  }

  export type $MailItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MailItem"
    objects: {
      folder: Prisma.$MailboxFolderPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      folderId: string
      messageId: string
      subject: string | null
      from: string | null
      receivedAt: Date | null
      listId: string | null
      listUnsubscribe: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["mailItem"]>
    composites: {}
  }

  type MailItemGetPayload<S extends boolean | null | undefined | MailItemDefaultArgs> = $Result.GetResult<Prisma.$MailItemPayload, S>

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

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

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

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

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

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

    /**
     * Create a MailItem.
     * @param {MailItemCreateArgs} args - Arguments to create a MailItem.
     * @example
     * // Create one MailItem
     * const MailItem = await prisma.mailItem.create({
     *   data: {
     *     // ... data to create a MailItem
     *   }
     * })
     * 
     */
    create<T extends MailItemCreateArgs>(args: SelectSubset<T, MailItemCreateArgs<ExtArgs>>): Prisma__MailItemClient<$Result.GetResult<Prisma.$MailItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a MailItem.
     * @param {MailItemDeleteArgs} args - Arguments to delete one MailItem.
     * @example
     * // Delete one MailItem
     * const MailItem = await prisma.mailItem.delete({
     *   where: {
     *     // ... filter to delete one MailItem
     *   }
     * })
     * 
     */
    delete<T extends MailItemDeleteArgs>(args: SelectSubset<T, MailItemDeleteArgs<ExtArgs>>): Prisma__MailItemClient<$Result.GetResult<Prisma.$MailItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for MailItem.
   * 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__MailItemClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    folder<T extends MailboxFolderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MailboxFolderDefaultArgs<ExtArgs>>): Prisma__MailboxFolderClient<$Result.GetResult<Prisma.$MailboxFolderPayload<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 MailItem model
   */ 
  interface MailItemFieldRefs {
    readonly id: FieldRef<"MailItem", 'String'>
    readonly folderId: FieldRef<"MailItem", 'String'>
    readonly messageId: FieldRef<"MailItem", 'String'>
    readonly subject: FieldRef<"MailItem", 'String'>
    readonly from: FieldRef<"MailItem", 'String'>
    readonly receivedAt: FieldRef<"MailItem", 'DateTime'>
    readonly listId: FieldRef<"MailItem", 'String'>
    readonly listUnsubscribe: FieldRef<"MailItem", 'String'>
    readonly createdAt: FieldRef<"MailItem", 'DateTime'>
    readonly updatedAt: FieldRef<"MailItem", 'DateTime'>
  }
    

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

  /**
   * MailItem findUniqueOrThrow
   */
  export type MailItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    /**
     * Filter, which MailItem to fetch.
     */
    where: MailItemWhereUniqueInput
  }

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

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

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

  /**
   * MailItem create
   */
  export type MailItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    /**
     * The data needed to create a MailItem.
     */
    data: XOR<MailItemCreateInput, MailItemUncheckedCreateInput>
  }

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

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

  /**
   * MailItem update
   */
  export type MailItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    /**
     * The data needed to update a MailItem.
     */
    data: XOR<MailItemUpdateInput, MailItemUncheckedUpdateInput>
    /**
     * Choose, which MailItem to update.
     */
    where: MailItemWhereUniqueInput
  }

  /**
   * MailItem updateMany
   */
  export type MailItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MailItems.
     */
    data: XOR<MailItemUpdateManyMutationInput, MailItemUncheckedUpdateManyInput>
    /**
     * Filter which MailItems to update
     */
    where?: MailItemWhereInput
  }

  /**
   * MailItem upsert
   */
  export type MailItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    /**
     * The filter to search for the MailItem to update in case it exists.
     */
    where: MailItemWhereUniqueInput
    /**
     * In case the MailItem found by the `where` argument doesn't exist, create a new MailItem with this data.
     */
    create: XOR<MailItemCreateInput, MailItemUncheckedCreateInput>
    /**
     * In case the MailItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MailItemUpdateInput, MailItemUncheckedUpdateInput>
  }

  /**
   * MailItem delete
   */
  export type MailItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MailItem
     */
    select?: MailItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MailItemInclude<ExtArgs> | null
    /**
     * Filter which MailItem to delete.
     */
    where: MailItemWhereUniqueInput
  }

  /**
   * MailItem deleteMany
   */
  export type MailItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MailItems to delete
     */
    where?: MailItemWhereInput
  }

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


  /**
   * Model Rule
   */

  export type AggregateRule = {
    _count: RuleCountAggregateOutputType | null
    _min: RuleMinAggregateOutputType | null
    _max: RuleMaxAggregateOutputType | null
  }

  export type RuleMinAggregateOutputType = {
    id: string | null
    tenantId: string | null
    name: string | null
    enabled: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type RuleMaxAggregateOutputType = {
    id: string | null
    tenantId: string | null
    name: string | null
    enabled: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type RuleCountAggregateOutputType = {
    id: number
    tenantId: number
    name: number
    enabled: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type RuleMinAggregateInputType = {
    id?: true
    tenantId?: true
    name?: true
    enabled?: true
    createdAt?: true
    updatedAt?: true
  }

  export type RuleMaxAggregateInputType = {
    id?: true
    tenantId?: true
    name?: true
    enabled?: true
    createdAt?: true
    updatedAt?: true
  }

  export type RuleCountAggregateInputType = {
    id?: true
    tenantId?: true
    name?: true
    enabled?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type RuleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleWhereInput
    orderBy?: RuleOrderByWithAggregationInput | RuleOrderByWithAggregationInput[]
    by: RuleScalarFieldEnum[] | RuleScalarFieldEnum
    having?: RuleScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RuleCountAggregateInputType | true
    _min?: RuleMinAggregateInputType
    _max?: RuleMaxAggregateInputType
  }

  export type RuleGroupByOutputType = {
    id: string
    tenantId: string
    name: string
    enabled: boolean
    createdAt: Date
    updatedAt: Date
    _count: RuleCountAggregateOutputType | null
    _min: RuleMinAggregateOutputType | null
    _max: RuleMaxAggregateOutputType | null
  }

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


  export type RuleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    name?: boolean
    enabled?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    conditions?: boolean | Rule$conditionsArgs<ExtArgs>
    actions?: boolean | Rule$actionsArgs<ExtArgs>
    _count?: boolean | RuleCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["rule"]>

  export type RuleSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    name?: boolean
    enabled?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["rule"]>

  export type RuleSelectScalar = {
    id?: boolean
    tenantId?: boolean
    name?: boolean
    enabled?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type RuleInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    conditions?: boolean | Rule$conditionsArgs<ExtArgs>
    actions?: boolean | Rule$actionsArgs<ExtArgs>
    _count?: boolean | RuleCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type RuleIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
  }

  export type $RulePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Rule"
    objects: {
      tenant: Prisma.$TenantPayload<ExtArgs>
      conditions: Prisma.$RuleConditionPayload<ExtArgs>[]
      actions: Prisma.$RuleActionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tenantId: string
      name: string
      enabled: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["rule"]>
    composites: {}
  }

  type RuleGetPayload<S extends boolean | null | undefined | RuleDefaultArgs> = $Result.GetResult<Prisma.$RulePayload, S>

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

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

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

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

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

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

    /**
     * Create a Rule.
     * @param {RuleCreateArgs} args - Arguments to create a Rule.
     * @example
     * // Create one Rule
     * const Rule = await prisma.rule.create({
     *   data: {
     *     // ... data to create a Rule
     *   }
     * })
     * 
     */
    create<T extends RuleCreateArgs>(args: SelectSubset<T, RuleCreateArgs<ExtArgs>>): Prisma__RuleClient<$Result.GetResult<Prisma.$RulePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Rule.
     * @param {RuleDeleteArgs} args - Arguments to delete one Rule.
     * @example
     * // Delete one Rule
     * const Rule = await prisma.rule.delete({
     *   where: {
     *     // ... filter to delete one Rule
     *   }
     * })
     * 
     */
    delete<T extends RuleDeleteArgs>(args: SelectSubset<T, RuleDeleteArgs<ExtArgs>>): Prisma__RuleClient<$Result.GetResult<Prisma.$RulePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Rule.
   * 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__RuleClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    tenant<T extends TenantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TenantDefaultArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    conditions<T extends Rule$conditionsArgs<ExtArgs> = {}>(args?: Subset<T, Rule$conditionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RuleConditionPayload<ExtArgs>, T, "findMany"> | Null>
    actions<T extends Rule$actionsArgs<ExtArgs> = {}>(args?: Subset<T, Rule$actionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RuleActionPayload<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 Rule model
   */ 
  interface RuleFieldRefs {
    readonly id: FieldRef<"Rule", 'String'>
    readonly tenantId: FieldRef<"Rule", 'String'>
    readonly name: FieldRef<"Rule", 'String'>
    readonly enabled: FieldRef<"Rule", 'Boolean'>
    readonly createdAt: FieldRef<"Rule", 'DateTime'>
    readonly updatedAt: FieldRef<"Rule", 'DateTime'>
  }
    

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

  /**
   * Rule findUniqueOrThrow
   */
  export type RuleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    /**
     * Filter, which Rule to fetch.
     */
    where: RuleWhereUniqueInput
  }

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

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

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

  /**
   * Rule create
   */
  export type RuleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    /**
     * The data needed to create a Rule.
     */
    data: XOR<RuleCreateInput, RuleUncheckedCreateInput>
  }

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

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

  /**
   * Rule update
   */
  export type RuleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    /**
     * The data needed to update a Rule.
     */
    data: XOR<RuleUpdateInput, RuleUncheckedUpdateInput>
    /**
     * Choose, which Rule to update.
     */
    where: RuleWhereUniqueInput
  }

  /**
   * Rule updateMany
   */
  export type RuleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Rules.
     */
    data: XOR<RuleUpdateManyMutationInput, RuleUncheckedUpdateManyInput>
    /**
     * Filter which Rules to update
     */
    where?: RuleWhereInput
  }

  /**
   * Rule upsert
   */
  export type RuleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    /**
     * The filter to search for the Rule to update in case it exists.
     */
    where: RuleWhereUniqueInput
    /**
     * In case the Rule found by the `where` argument doesn't exist, create a new Rule with this data.
     */
    create: XOR<RuleCreateInput, RuleUncheckedCreateInput>
    /**
     * In case the Rule was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RuleUpdateInput, RuleUncheckedUpdateInput>
  }

  /**
   * Rule delete
   */
  export type RuleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Rule
     */
    select?: RuleSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleInclude<ExtArgs> | null
    /**
     * Filter which Rule to delete.
     */
    where: RuleWhereUniqueInput
  }

  /**
   * Rule deleteMany
   */
  export type RuleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Rules to delete
     */
    where?: RuleWhereInput
  }

  /**
   * Rule.conditions
   */
  export type Rule$conditionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    where?: RuleConditionWhereInput
    orderBy?: RuleConditionOrderByWithRelationInput | RuleConditionOrderByWithRelationInput[]
    cursor?: RuleConditionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RuleConditionScalarFieldEnum | RuleConditionScalarFieldEnum[]
  }

  /**
   * Rule.actions
   */
  export type Rule$actionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    where?: RuleActionWhereInput
    orderBy?: RuleActionOrderByWithRelationInput | RuleActionOrderByWithRelationInput[]
    cursor?: RuleActionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RuleActionScalarFieldEnum | RuleActionScalarFieldEnum[]
  }

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


  /**
   * Model RuleCondition
   */

  export type AggregateRuleCondition = {
    _count: RuleConditionCountAggregateOutputType | null
    _min: RuleConditionMinAggregateOutputType | null
    _max: RuleConditionMaxAggregateOutputType | null
  }

  export type RuleConditionMinAggregateOutputType = {
    id: string | null
    ruleId: string | null
    type: $Enums.RuleConditionType | null
    value: string | null
  }

  export type RuleConditionMaxAggregateOutputType = {
    id: string | null
    ruleId: string | null
    type: $Enums.RuleConditionType | null
    value: string | null
  }

  export type RuleConditionCountAggregateOutputType = {
    id: number
    ruleId: number
    type: number
    value: number
    _all: number
  }


  export type RuleConditionMinAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    value?: true
  }

  export type RuleConditionMaxAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    value?: true
  }

  export type RuleConditionCountAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    value?: true
    _all?: true
  }

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

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




  export type RuleConditionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleConditionWhereInput
    orderBy?: RuleConditionOrderByWithAggregationInput | RuleConditionOrderByWithAggregationInput[]
    by: RuleConditionScalarFieldEnum[] | RuleConditionScalarFieldEnum
    having?: RuleConditionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RuleConditionCountAggregateInputType | true
    _min?: RuleConditionMinAggregateInputType
    _max?: RuleConditionMaxAggregateInputType
  }

  export type RuleConditionGroupByOutputType = {
    id: string
    ruleId: string
    type: $Enums.RuleConditionType
    value: string
    _count: RuleConditionCountAggregateOutputType | null
    _min: RuleConditionMinAggregateOutputType | null
    _max: RuleConditionMaxAggregateOutputType | null
  }

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


  export type RuleConditionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    ruleId?: boolean
    type?: boolean
    value?: boolean
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["ruleCondition"]>

  export type RuleConditionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    ruleId?: boolean
    type?: boolean
    value?: boolean
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["ruleCondition"]>

  export type RuleConditionSelectScalar = {
    id?: boolean
    ruleId?: boolean
    type?: boolean
    value?: boolean
  }

  export type RuleConditionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }
  export type RuleConditionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }

  export type $RuleConditionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RuleCondition"
    objects: {
      rule: Prisma.$RulePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      ruleId: string
      type: $Enums.RuleConditionType
      value: string
    }, ExtArgs["result"]["ruleCondition"]>
    composites: {}
  }

  type RuleConditionGetPayload<S extends boolean | null | undefined | RuleConditionDefaultArgs> = $Result.GetResult<Prisma.$RuleConditionPayload, S>

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

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

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

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

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

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

    /**
     * Create a RuleCondition.
     * @param {RuleConditionCreateArgs} args - Arguments to create a RuleCondition.
     * @example
     * // Create one RuleCondition
     * const RuleCondition = await prisma.ruleCondition.create({
     *   data: {
     *     // ... data to create a RuleCondition
     *   }
     * })
     * 
     */
    create<T extends RuleConditionCreateArgs>(args: SelectSubset<T, RuleConditionCreateArgs<ExtArgs>>): Prisma__RuleConditionClient<$Result.GetResult<Prisma.$RuleConditionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a RuleCondition.
     * @param {RuleConditionDeleteArgs} args - Arguments to delete one RuleCondition.
     * @example
     * // Delete one RuleCondition
     * const RuleCondition = await prisma.ruleCondition.delete({
     *   where: {
     *     // ... filter to delete one RuleCondition
     *   }
     * })
     * 
     */
    delete<T extends RuleConditionDeleteArgs>(args: SelectSubset<T, RuleConditionDeleteArgs<ExtArgs>>): Prisma__RuleConditionClient<$Result.GetResult<Prisma.$RuleConditionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for RuleCondition.
   * 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__RuleConditionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    rule<T extends RuleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, RuleDefaultArgs<ExtArgs>>): Prisma__RuleClient<$Result.GetResult<Prisma.$RulePayload<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 RuleCondition model
   */ 
  interface RuleConditionFieldRefs {
    readonly id: FieldRef<"RuleCondition", 'String'>
    readonly ruleId: FieldRef<"RuleCondition", 'String'>
    readonly type: FieldRef<"RuleCondition", 'RuleConditionType'>
    readonly value: FieldRef<"RuleCondition", 'String'>
  }
    

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

  /**
   * RuleCondition findUniqueOrThrow
   */
  export type RuleConditionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    /**
     * Filter, which RuleCondition to fetch.
     */
    where: RuleConditionWhereUniqueInput
  }

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

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

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

  /**
   * RuleCondition create
   */
  export type RuleConditionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    /**
     * The data needed to create a RuleCondition.
     */
    data: XOR<RuleConditionCreateInput, RuleConditionUncheckedCreateInput>
  }

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

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

  /**
   * RuleCondition update
   */
  export type RuleConditionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    /**
     * The data needed to update a RuleCondition.
     */
    data: XOR<RuleConditionUpdateInput, RuleConditionUncheckedUpdateInput>
    /**
     * Choose, which RuleCondition to update.
     */
    where: RuleConditionWhereUniqueInput
  }

  /**
   * RuleCondition updateMany
   */
  export type RuleConditionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RuleConditions.
     */
    data: XOR<RuleConditionUpdateManyMutationInput, RuleConditionUncheckedUpdateManyInput>
    /**
     * Filter which RuleConditions to update
     */
    where?: RuleConditionWhereInput
  }

  /**
   * RuleCondition upsert
   */
  export type RuleConditionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    /**
     * The filter to search for the RuleCondition to update in case it exists.
     */
    where: RuleConditionWhereUniqueInput
    /**
     * In case the RuleCondition found by the `where` argument doesn't exist, create a new RuleCondition with this data.
     */
    create: XOR<RuleConditionCreateInput, RuleConditionUncheckedCreateInput>
    /**
     * In case the RuleCondition was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RuleConditionUpdateInput, RuleConditionUncheckedUpdateInput>
  }

  /**
   * RuleCondition delete
   */
  export type RuleConditionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleCondition
     */
    select?: RuleConditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleConditionInclude<ExtArgs> | null
    /**
     * Filter which RuleCondition to delete.
     */
    where: RuleConditionWhereUniqueInput
  }

  /**
   * RuleCondition deleteMany
   */
  export type RuleConditionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RuleConditions to delete
     */
    where?: RuleConditionWhereInput
  }

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


  /**
   * Model RuleAction
   */

  export type AggregateRuleAction = {
    _count: RuleActionCountAggregateOutputType | null
    _min: RuleActionMinAggregateOutputType | null
    _max: RuleActionMaxAggregateOutputType | null
  }

  export type RuleActionMinAggregateOutputType = {
    id: string | null
    ruleId: string | null
    type: $Enums.RuleActionType | null
    target: string | null
  }

  export type RuleActionMaxAggregateOutputType = {
    id: string | null
    ruleId: string | null
    type: $Enums.RuleActionType | null
    target: string | null
  }

  export type RuleActionCountAggregateOutputType = {
    id: number
    ruleId: number
    type: number
    target: number
    _all: number
  }


  export type RuleActionMinAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    target?: true
  }

  export type RuleActionMaxAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    target?: true
  }

  export type RuleActionCountAggregateInputType = {
    id?: true
    ruleId?: true
    type?: true
    target?: true
    _all?: true
  }

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

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




  export type RuleActionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RuleActionWhereInput
    orderBy?: RuleActionOrderByWithAggregationInput | RuleActionOrderByWithAggregationInput[]
    by: RuleActionScalarFieldEnum[] | RuleActionScalarFieldEnum
    having?: RuleActionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RuleActionCountAggregateInputType | true
    _min?: RuleActionMinAggregateInputType
    _max?: RuleActionMaxAggregateInputType
  }

  export type RuleActionGroupByOutputType = {
    id: string
    ruleId: string
    type: $Enums.RuleActionType
    target: string | null
    _count: RuleActionCountAggregateOutputType | null
    _min: RuleActionMinAggregateOutputType | null
    _max: RuleActionMaxAggregateOutputType | null
  }

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


  export type RuleActionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    ruleId?: boolean
    type?: boolean
    target?: boolean
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["ruleAction"]>

  export type RuleActionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    ruleId?: boolean
    type?: boolean
    target?: boolean
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["ruleAction"]>

  export type RuleActionSelectScalar = {
    id?: boolean
    ruleId?: boolean
    type?: boolean
    target?: boolean
  }

  export type RuleActionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }
  export type RuleActionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rule?: boolean | RuleDefaultArgs<ExtArgs>
  }

  export type $RuleActionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RuleAction"
    objects: {
      rule: Prisma.$RulePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      ruleId: string
      type: $Enums.RuleActionType
      target: string | null
    }, ExtArgs["result"]["ruleAction"]>
    composites: {}
  }

  type RuleActionGetPayload<S extends boolean | null | undefined | RuleActionDefaultArgs> = $Result.GetResult<Prisma.$RuleActionPayload, S>

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

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

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

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

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

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

    /**
     * Create a RuleAction.
     * @param {RuleActionCreateArgs} args - Arguments to create a RuleAction.
     * @example
     * // Create one RuleAction
     * const RuleAction = await prisma.ruleAction.create({
     *   data: {
     *     // ... data to create a RuleAction
     *   }
     * })
     * 
     */
    create<T extends RuleActionCreateArgs>(args: SelectSubset<T, RuleActionCreateArgs<ExtArgs>>): Prisma__RuleActionClient<$Result.GetResult<Prisma.$RuleActionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a RuleAction.
     * @param {RuleActionDeleteArgs} args - Arguments to delete one RuleAction.
     * @example
     * // Delete one RuleAction
     * const RuleAction = await prisma.ruleAction.delete({
     *   where: {
     *     // ... filter to delete one RuleAction
     *   }
     * })
     * 
     */
    delete<T extends RuleActionDeleteArgs>(args: SelectSubset<T, RuleActionDeleteArgs<ExtArgs>>): Prisma__RuleActionClient<$Result.GetResult<Prisma.$RuleActionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for RuleAction.
   * 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__RuleActionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    rule<T extends RuleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, RuleDefaultArgs<ExtArgs>>): Prisma__RuleClient<$Result.GetResult<Prisma.$RulePayload<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 RuleAction model
   */ 
  interface RuleActionFieldRefs {
    readonly id: FieldRef<"RuleAction", 'String'>
    readonly ruleId: FieldRef<"RuleAction", 'String'>
    readonly type: FieldRef<"RuleAction", 'RuleActionType'>
    readonly target: FieldRef<"RuleAction", 'String'>
  }
    

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

  /**
   * RuleAction findUniqueOrThrow
   */
  export type RuleActionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    /**
     * Filter, which RuleAction to fetch.
     */
    where: RuleActionWhereUniqueInput
  }

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

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

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

  /**
   * RuleAction create
   */
  export type RuleActionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    /**
     * The data needed to create a RuleAction.
     */
    data: XOR<RuleActionCreateInput, RuleActionUncheckedCreateInput>
  }

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

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

  /**
   * RuleAction update
   */
  export type RuleActionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    /**
     * The data needed to update a RuleAction.
     */
    data: XOR<RuleActionUpdateInput, RuleActionUncheckedUpdateInput>
    /**
     * Choose, which RuleAction to update.
     */
    where: RuleActionWhereUniqueInput
  }

  /**
   * RuleAction updateMany
   */
  export type RuleActionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RuleActions.
     */
    data: XOR<RuleActionUpdateManyMutationInput, RuleActionUncheckedUpdateManyInput>
    /**
     * Filter which RuleActions to update
     */
    where?: RuleActionWhereInput
  }

  /**
   * RuleAction upsert
   */
  export type RuleActionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    /**
     * The filter to search for the RuleAction to update in case it exists.
     */
    where: RuleActionWhereUniqueInput
    /**
     * In case the RuleAction found by the `where` argument doesn't exist, create a new RuleAction with this data.
     */
    create: XOR<RuleActionCreateInput, RuleActionUncheckedCreateInput>
    /**
     * In case the RuleAction was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RuleActionUpdateInput, RuleActionUncheckedUpdateInput>
  }

  /**
   * RuleAction delete
   */
  export type RuleActionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RuleAction
     */
    select?: RuleActionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RuleActionInclude<ExtArgs> | null
    /**
     * Filter which RuleAction to delete.
     */
    where: RuleActionWhereUniqueInput
  }

  /**
   * RuleAction deleteMany
   */
  export type RuleActionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RuleActions to delete
     */
    where?: RuleActionWhereInput
  }

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


  /**
   * Model CleanupJob
   */

  export type AggregateCleanupJob = {
    _count: CleanupJobCountAggregateOutputType | null
    _min: CleanupJobMinAggregateOutputType | null
    _max: CleanupJobMaxAggregateOutputType | null
  }

  export type CleanupJobMinAggregateOutputType = {
    id: string | null
    tenantId: string | null
    mailboxAccountId: string | null
    status: $Enums.JobStatus | null
    dryRun: boolean | null
    unsubscribeEnabled: boolean | null
    routingEnabled: boolean | null
    startedAt: Date | null
    finishedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CleanupJobMaxAggregateOutputType = {
    id: string | null
    tenantId: string | null
    mailboxAccountId: string | null
    status: $Enums.JobStatus | null
    dryRun: boolean | null
    unsubscribeEnabled: boolean | null
    routingEnabled: boolean | null
    startedAt: Date | null
    finishedAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CleanupJobCountAggregateOutputType = {
    id: number
    tenantId: number
    mailboxAccountId: number
    status: number
    dryRun: number
    unsubscribeEnabled: number
    routingEnabled: number
    startedAt: number
    finishedAt: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type CleanupJobMinAggregateInputType = {
    id?: true
    tenantId?: true
    mailboxAccountId?: true
    status?: true
    dryRun?: true
    unsubscribeEnabled?: true
    routingEnabled?: true
    startedAt?: true
    finishedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CleanupJobMaxAggregateInputType = {
    id?: true
    tenantId?: true
    mailboxAccountId?: true
    status?: true
    dryRun?: true
    unsubscribeEnabled?: true
    routingEnabled?: true
    startedAt?: true
    finishedAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CleanupJobCountAggregateInputType = {
    id?: true
    tenantId?: true
    mailboxAccountId?: true
    status?: true
    dryRun?: true
    unsubscribeEnabled?: true
    routingEnabled?: true
    startedAt?: true
    finishedAt?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type CleanupJobGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CleanupJobWhereInput
    orderBy?: CleanupJobOrderByWithAggregationInput | CleanupJobOrderByWithAggregationInput[]
    by: CleanupJobScalarFieldEnum[] | CleanupJobScalarFieldEnum
    having?: CleanupJobScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CleanupJobCountAggregateInputType | true
    _min?: CleanupJobMinAggregateInputType
    _max?: CleanupJobMaxAggregateInputType
  }

  export type CleanupJobGroupByOutputType = {
    id: string
    tenantId: string
    mailboxAccountId: string
    status: $Enums.JobStatus
    dryRun: boolean
    unsubscribeEnabled: boolean
    routingEnabled: boolean
    startedAt: Date | null
    finishedAt: Date | null
    createdAt: Date
    updatedAt: Date
    _count: CleanupJobCountAggregateOutputType | null
    _min: CleanupJobMinAggregateOutputType | null
    _max: CleanupJobMaxAggregateOutputType | null
  }

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


  export type CleanupJobSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    mailboxAccountId?: boolean
    status?: boolean
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
    unsubscribeAttempts?: boolean | CleanupJob$unsubscribeAttemptsArgs<ExtArgs>
    events?: boolean | CleanupJob$eventsArgs<ExtArgs>
    _count?: boolean | CleanupJobCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cleanupJob"]>

  export type CleanupJobSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tenantId?: boolean
    mailboxAccountId?: boolean
    status?: boolean
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cleanupJob"]>

  export type CleanupJobSelectScalar = {
    id?: boolean
    tenantId?: boolean
    mailboxAccountId?: boolean
    status?: boolean
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CleanupJobInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
    unsubscribeAttempts?: boolean | CleanupJob$unsubscribeAttemptsArgs<ExtArgs>
    events?: boolean | CleanupJob$eventsArgs<ExtArgs>
    _count?: boolean | CleanupJobCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CleanupJobIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tenant?: boolean | TenantDefaultArgs<ExtArgs>
    mailboxAccount?: boolean | MailboxAccountDefaultArgs<ExtArgs>
  }

  export type $CleanupJobPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CleanupJob"
    objects: {
      tenant: Prisma.$TenantPayload<ExtArgs>
      mailboxAccount: Prisma.$MailboxAccountPayload<ExtArgs>
      unsubscribeAttempts: Prisma.$UnsubscribeAttemptPayload<ExtArgs>[]
      events: Prisma.$CleanupJobEventPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tenantId: string
      mailboxAccountId: string
      status: $Enums.JobStatus
      dryRun: boolean
      unsubscribeEnabled: boolean
      routingEnabled: boolean
      startedAt: Date | null
      finishedAt: Date | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["cleanupJob"]>
    composites: {}
  }

  type CleanupJobGetPayload<S extends boolean | null | undefined | CleanupJobDefaultArgs> = $Result.GetResult<Prisma.$CleanupJobPayload, S>

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

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

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

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

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

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

    /**
     * Create a CleanupJob.
     * @param {CleanupJobCreateArgs} args - Arguments to create a CleanupJob.
     * @example
     * // Create one CleanupJob
     * const CleanupJob = await prisma.cleanupJob.create({
     *   data: {
     *     // ... data to create a CleanupJob
     *   }
     * })
     * 
     */
    create<T extends CleanupJobCreateArgs>(args: SelectSubset<T, CleanupJobCreateArgs<ExtArgs>>): Prisma__CleanupJobClient<$Result.GetResult<Prisma.$CleanupJobPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a CleanupJob.
     * @param {CleanupJobDeleteArgs} args - Arguments to delete one CleanupJob.
     * @example
     * // Delete one CleanupJob
     * const CleanupJob = await prisma.cleanupJob.delete({
     *   where: {
     *     // ... filter to delete one CleanupJob
     *   }
     * })
     * 
     */
    delete<T extends CleanupJobDeleteArgs>(args: SelectSubset<T, CleanupJobDeleteArgs<ExtArgs>>): Prisma__CleanupJobClient<$Result.GetResult<Prisma.$CleanupJobPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CleanupJob.
   * 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__CleanupJobClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    tenant<T extends TenantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TenantDefaultArgs<ExtArgs>>): Prisma__TenantClient<$Result.GetResult<Prisma.$TenantPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    mailboxAccount<T extends MailboxAccountDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MailboxAccountDefaultArgs<ExtArgs>>): Prisma__MailboxAccountClient<$Result.GetResult<Prisma.$MailboxAccountPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    unsubscribeAttempts<T extends CleanupJob$unsubscribeAttemptsArgs<ExtArgs> = {}>(args?: Subset<T, CleanupJob$unsubscribeAttemptsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UnsubscribeAttemptPayload<ExtArgs>, T, "findMany"> | Null>
    events<T extends CleanupJob$eventsArgs<ExtArgs> = {}>(args?: Subset<T, CleanupJob$eventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CleanupJobEventPayload<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 CleanupJob model
   */ 
  interface CleanupJobFieldRefs {
    readonly id: FieldRef<"CleanupJob", 'String'>
    readonly tenantId: FieldRef<"CleanupJob", 'String'>
    readonly mailboxAccountId: FieldRef<"CleanupJob", 'String'>
    readonly status: FieldRef<"CleanupJob", 'JobStatus'>
    readonly dryRun: FieldRef<"CleanupJob", 'Boolean'>
    readonly unsubscribeEnabled: FieldRef<"CleanupJob", 'Boolean'>
    readonly routingEnabled: FieldRef<"CleanupJob", 'Boolean'>
    readonly startedAt: FieldRef<"CleanupJob", 'DateTime'>
    readonly finishedAt: FieldRef<"CleanupJob", 'DateTime'>
    readonly createdAt: FieldRef<"CleanupJob", 'DateTime'>
    readonly updatedAt: FieldRef<"CleanupJob", 'DateTime'>
  }
    

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

  /**
   * CleanupJob findUniqueOrThrow
   */
  export type CleanupJobFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    /**
     * Filter, which CleanupJob to fetch.
     */
    where: CleanupJobWhereUniqueInput
  }

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

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

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

  /**
   * CleanupJob create
   */
  export type CleanupJobCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    /**
     * The data needed to create a CleanupJob.
     */
    data: XOR<CleanupJobCreateInput, CleanupJobUncheckedCreateInput>
  }

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

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

  /**
   * CleanupJob update
   */
  export type CleanupJobUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    /**
     * The data needed to update a CleanupJob.
     */
    data: XOR<CleanupJobUpdateInput, CleanupJobUncheckedUpdateInput>
    /**
     * Choose, which CleanupJob to update.
     */
    where: CleanupJobWhereUniqueInput
  }

  /**
   * CleanupJob updateMany
   */
  export type CleanupJobUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CleanupJobs.
     */
    data: XOR<CleanupJobUpdateManyMutationInput, CleanupJobUncheckedUpdateManyInput>
    /**
     * Filter which CleanupJobs to update
     */
    where?: CleanupJobWhereInput
  }

  /**
   * CleanupJob upsert
   */
  export type CleanupJobUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    /**
     * The filter to search for the CleanupJob to update in case it exists.
     */
    where: CleanupJobWhereUniqueInput
    /**
     * In case the CleanupJob found by the `where` argument doesn't exist, create a new CleanupJob with this data.
     */
    create: XOR<CleanupJobCreateInput, CleanupJobUncheckedCreateInput>
    /**
     * In case the CleanupJob was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CleanupJobUpdateInput, CleanupJobUncheckedUpdateInput>
  }

  /**
   * CleanupJob delete
   */
  export type CleanupJobDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJob
     */
    select?: CleanupJobSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobInclude<ExtArgs> | null
    /**
     * Filter which CleanupJob to delete.
     */
    where: CleanupJobWhereUniqueInput
  }

  /**
   * CleanupJob deleteMany
   */
  export type CleanupJobDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CleanupJobs to delete
     */
    where?: CleanupJobWhereInput
  }

  /**
   * CleanupJob.unsubscribeAttempts
   */
  export type CleanupJob$unsubscribeAttemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    where?: UnsubscribeAttemptWhereInput
    orderBy?: UnsubscribeAttemptOrderByWithRelationInput | UnsubscribeAttemptOrderByWithRelationInput[]
    cursor?: UnsubscribeAttemptWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UnsubscribeAttemptScalarFieldEnum | UnsubscribeAttemptScalarFieldEnum[]
  }

  /**
   * CleanupJob.events
   */
  export type CleanupJob$eventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    where?: CleanupJobEventWhereInput
    orderBy?: CleanupJobEventOrderByWithRelationInput | CleanupJobEventOrderByWithRelationInput[]
    cursor?: CleanupJobEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CleanupJobEventScalarFieldEnum | CleanupJobEventScalarFieldEnum[]
  }

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


  /**
   * Model UnsubscribeAttempt
   */

  export type AggregateUnsubscribeAttempt = {
    _count: UnsubscribeAttemptCountAggregateOutputType | null
    _min: UnsubscribeAttemptMinAggregateOutputType | null
    _max: UnsubscribeAttemptMaxAggregateOutputType | null
  }

  export type UnsubscribeAttemptMinAggregateOutputType = {
    id: string | null
    jobId: string | null
    mailItemId: string | null
    method: string | null
    target: string | null
    status: string | null
    createdAt: Date | null
  }

  export type UnsubscribeAttemptMaxAggregateOutputType = {
    id: string | null
    jobId: string | null
    mailItemId: string | null
    method: string | null
    target: string | null
    status: string | null
    createdAt: Date | null
  }

  export type UnsubscribeAttemptCountAggregateOutputType = {
    id: number
    jobId: number
    mailItemId: number
    method: number
    target: number
    status: number
    createdAt: number
    _all: number
  }


  export type UnsubscribeAttemptMinAggregateInputType = {
    id?: true
    jobId?: true
    mailItemId?: true
    method?: true
    target?: true
    status?: true
    createdAt?: true
  }

  export type UnsubscribeAttemptMaxAggregateInputType = {
    id?: true
    jobId?: true
    mailItemId?: true
    method?: true
    target?: true
    status?: true
    createdAt?: true
  }

  export type UnsubscribeAttemptCountAggregateInputType = {
    id?: true
    jobId?: true
    mailItemId?: true
    method?: true
    target?: true
    status?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type UnsubscribeAttemptGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UnsubscribeAttemptWhereInput
    orderBy?: UnsubscribeAttemptOrderByWithAggregationInput | UnsubscribeAttemptOrderByWithAggregationInput[]
    by: UnsubscribeAttemptScalarFieldEnum[] | UnsubscribeAttemptScalarFieldEnum
    having?: UnsubscribeAttemptScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UnsubscribeAttemptCountAggregateInputType | true
    _min?: UnsubscribeAttemptMinAggregateInputType
    _max?: UnsubscribeAttemptMaxAggregateInputType
  }

  export type UnsubscribeAttemptGroupByOutputType = {
    id: string
    jobId: string
    mailItemId: string | null
    method: string
    target: string
    status: string
    createdAt: Date
    _count: UnsubscribeAttemptCountAggregateOutputType | null
    _min: UnsubscribeAttemptMinAggregateOutputType | null
    _max: UnsubscribeAttemptMaxAggregateOutputType | null
  }

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


  export type UnsubscribeAttemptSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobId?: boolean
    mailItemId?: boolean
    method?: boolean
    target?: boolean
    status?: boolean
    createdAt?: boolean
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["unsubscribeAttempt"]>

  export type UnsubscribeAttemptSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobId?: boolean
    mailItemId?: boolean
    method?: boolean
    target?: boolean
    status?: boolean
    createdAt?: boolean
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["unsubscribeAttempt"]>

  export type UnsubscribeAttemptSelectScalar = {
    id?: boolean
    jobId?: boolean
    mailItemId?: boolean
    method?: boolean
    target?: boolean
    status?: boolean
    createdAt?: boolean
  }

  export type UnsubscribeAttemptInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }
  export type UnsubscribeAttemptIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }

  export type $UnsubscribeAttemptPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UnsubscribeAttempt"
    objects: {
      job: Prisma.$CleanupJobPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      jobId: string
      mailItemId: string | null
      method: string
      target: string
      status: string
      createdAt: Date
    }, ExtArgs["result"]["unsubscribeAttempt"]>
    composites: {}
  }

  type UnsubscribeAttemptGetPayload<S extends boolean | null | undefined | UnsubscribeAttemptDefaultArgs> = $Result.GetResult<Prisma.$UnsubscribeAttemptPayload, S>

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

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

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

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

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

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

    /**
     * Create a UnsubscribeAttempt.
     * @param {UnsubscribeAttemptCreateArgs} args - Arguments to create a UnsubscribeAttempt.
     * @example
     * // Create one UnsubscribeAttempt
     * const UnsubscribeAttempt = await prisma.unsubscribeAttempt.create({
     *   data: {
     *     // ... data to create a UnsubscribeAttempt
     *   }
     * })
     * 
     */
    create<T extends UnsubscribeAttemptCreateArgs>(args: SelectSubset<T, UnsubscribeAttemptCreateArgs<ExtArgs>>): Prisma__UnsubscribeAttemptClient<$Result.GetResult<Prisma.$UnsubscribeAttemptPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a UnsubscribeAttempt.
     * @param {UnsubscribeAttemptDeleteArgs} args - Arguments to delete one UnsubscribeAttempt.
     * @example
     * // Delete one UnsubscribeAttempt
     * const UnsubscribeAttempt = await prisma.unsubscribeAttempt.delete({
     *   where: {
     *     // ... filter to delete one UnsubscribeAttempt
     *   }
     * })
     * 
     */
    delete<T extends UnsubscribeAttemptDeleteArgs>(args: SelectSubset<T, UnsubscribeAttemptDeleteArgs<ExtArgs>>): Prisma__UnsubscribeAttemptClient<$Result.GetResult<Prisma.$UnsubscribeAttemptPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UnsubscribeAttempt.
   * 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__UnsubscribeAttemptClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    job<T extends CleanupJobDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CleanupJobDefaultArgs<ExtArgs>>): Prisma__CleanupJobClient<$Result.GetResult<Prisma.$CleanupJobPayload<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 UnsubscribeAttempt model
   */ 
  interface UnsubscribeAttemptFieldRefs {
    readonly id: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly jobId: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly mailItemId: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly method: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly target: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly status: FieldRef<"UnsubscribeAttempt", 'String'>
    readonly createdAt: FieldRef<"UnsubscribeAttempt", 'DateTime'>
  }
    

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

  /**
   * UnsubscribeAttempt findUniqueOrThrow
   */
  export type UnsubscribeAttemptFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    /**
     * Filter, which UnsubscribeAttempt to fetch.
     */
    where: UnsubscribeAttemptWhereUniqueInput
  }

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

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

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

  /**
   * UnsubscribeAttempt create
   */
  export type UnsubscribeAttemptCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    /**
     * The data needed to create a UnsubscribeAttempt.
     */
    data: XOR<UnsubscribeAttemptCreateInput, UnsubscribeAttemptUncheckedCreateInput>
  }

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

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

  /**
   * UnsubscribeAttempt update
   */
  export type UnsubscribeAttemptUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    /**
     * The data needed to update a UnsubscribeAttempt.
     */
    data: XOR<UnsubscribeAttemptUpdateInput, UnsubscribeAttemptUncheckedUpdateInput>
    /**
     * Choose, which UnsubscribeAttempt to update.
     */
    where: UnsubscribeAttemptWhereUniqueInput
  }

  /**
   * UnsubscribeAttempt updateMany
   */
  export type UnsubscribeAttemptUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UnsubscribeAttempts.
     */
    data: XOR<UnsubscribeAttemptUpdateManyMutationInput, UnsubscribeAttemptUncheckedUpdateManyInput>
    /**
     * Filter which UnsubscribeAttempts to update
     */
    where?: UnsubscribeAttemptWhereInput
  }

  /**
   * UnsubscribeAttempt upsert
   */
  export type UnsubscribeAttemptUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    /**
     * The filter to search for the UnsubscribeAttempt to update in case it exists.
     */
    where: UnsubscribeAttemptWhereUniqueInput
    /**
     * In case the UnsubscribeAttempt found by the `where` argument doesn't exist, create a new UnsubscribeAttempt with this data.
     */
    create: XOR<UnsubscribeAttemptCreateInput, UnsubscribeAttemptUncheckedCreateInput>
    /**
     * In case the UnsubscribeAttempt was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UnsubscribeAttemptUpdateInput, UnsubscribeAttemptUncheckedUpdateInput>
  }

  /**
   * UnsubscribeAttempt delete
   */
  export type UnsubscribeAttemptDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UnsubscribeAttempt
     */
    select?: UnsubscribeAttemptSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UnsubscribeAttemptInclude<ExtArgs> | null
    /**
     * Filter which UnsubscribeAttempt to delete.
     */
    where: UnsubscribeAttemptWhereUniqueInput
  }

  /**
   * UnsubscribeAttempt deleteMany
   */
  export type UnsubscribeAttemptDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UnsubscribeAttempts to delete
     */
    where?: UnsubscribeAttemptWhereInput
  }

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


  /**
   * Model CleanupJobEvent
   */

  export type AggregateCleanupJobEvent = {
    _count: CleanupJobEventCountAggregateOutputType | null
    _avg: CleanupJobEventAvgAggregateOutputType | null
    _sum: CleanupJobEventSumAggregateOutputType | null
    _min: CleanupJobEventMinAggregateOutputType | null
    _max: CleanupJobEventMaxAggregateOutputType | null
  }

  export type CleanupJobEventAvgAggregateOutputType = {
    progress: number | null
  }

  export type CleanupJobEventSumAggregateOutputType = {
    progress: number | null
  }

  export type CleanupJobEventMinAggregateOutputType = {
    id: string | null
    jobId: string | null
    level: string | null
    message: string | null
    progress: number | null
    createdAt: Date | null
  }

  export type CleanupJobEventMaxAggregateOutputType = {
    id: string | null
    jobId: string | null
    level: string | null
    message: string | null
    progress: number | null
    createdAt: Date | null
  }

  export type CleanupJobEventCountAggregateOutputType = {
    id: number
    jobId: number
    level: number
    message: number
    progress: number
    createdAt: number
    _all: number
  }


  export type CleanupJobEventAvgAggregateInputType = {
    progress?: true
  }

  export type CleanupJobEventSumAggregateInputType = {
    progress?: true
  }

  export type CleanupJobEventMinAggregateInputType = {
    id?: true
    jobId?: true
    level?: true
    message?: true
    progress?: true
    createdAt?: true
  }

  export type CleanupJobEventMaxAggregateInputType = {
    id?: true
    jobId?: true
    level?: true
    message?: true
    progress?: true
    createdAt?: true
  }

  export type CleanupJobEventCountAggregateInputType = {
    id?: true
    jobId?: true
    level?: true
    message?: true
    progress?: true
    createdAt?: true
    _all?: true
  }

  export type CleanupJobEventAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CleanupJobEvent to aggregate.
     */
    where?: CleanupJobEventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CleanupJobEvents to fetch.
     */
    orderBy?: CleanupJobEventOrderByWithRelationInput | CleanupJobEventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CleanupJobEventWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CleanupJobEvents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CleanupJobEvents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CleanupJobEvents
    **/
    _count?: true | CleanupJobEventCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CleanupJobEventAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CleanupJobEventSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CleanupJobEventMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CleanupJobEventMaxAggregateInputType
  }

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




  export type CleanupJobEventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CleanupJobEventWhereInput
    orderBy?: CleanupJobEventOrderByWithAggregationInput | CleanupJobEventOrderByWithAggregationInput[]
    by: CleanupJobEventScalarFieldEnum[] | CleanupJobEventScalarFieldEnum
    having?: CleanupJobEventScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CleanupJobEventCountAggregateInputType | true
    _avg?: CleanupJobEventAvgAggregateInputType
    _sum?: CleanupJobEventSumAggregateInputType
    _min?: CleanupJobEventMinAggregateInputType
    _max?: CleanupJobEventMaxAggregateInputType
  }

  export type CleanupJobEventGroupByOutputType = {
    id: string
    jobId: string
    level: string
    message: string
    progress: number | null
    createdAt: Date
    _count: CleanupJobEventCountAggregateOutputType | null
    _avg: CleanupJobEventAvgAggregateOutputType | null
    _sum: CleanupJobEventSumAggregateOutputType | null
    _min: CleanupJobEventMinAggregateOutputType | null
    _max: CleanupJobEventMaxAggregateOutputType | null
  }

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


  export type CleanupJobEventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobId?: boolean
    level?: boolean
    message?: boolean
    progress?: boolean
    createdAt?: boolean
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cleanupJobEvent"]>

  export type CleanupJobEventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jobId?: boolean
    level?: boolean
    message?: boolean
    progress?: boolean
    createdAt?: boolean
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cleanupJobEvent"]>

  export type CleanupJobEventSelectScalar = {
    id?: boolean
    jobId?: boolean
    level?: boolean
    message?: boolean
    progress?: boolean
    createdAt?: boolean
  }

  export type CleanupJobEventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }
  export type CleanupJobEventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    job?: boolean | CleanupJobDefaultArgs<ExtArgs>
  }

  export type $CleanupJobEventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CleanupJobEvent"
    objects: {
      job: Prisma.$CleanupJobPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      jobId: string
      level: string
      message: string
      progress: number | null
      createdAt: Date
    }, ExtArgs["result"]["cleanupJobEvent"]>
    composites: {}
  }

  type CleanupJobEventGetPayload<S extends boolean | null | undefined | CleanupJobEventDefaultArgs> = $Result.GetResult<Prisma.$CleanupJobEventPayload, S>

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

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

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

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

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

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

    /**
     * Create a CleanupJobEvent.
     * @param {CleanupJobEventCreateArgs} args - Arguments to create a CleanupJobEvent.
     * @example
     * // Create one CleanupJobEvent
     * const CleanupJobEvent = await prisma.cleanupJobEvent.create({
     *   data: {
     *     // ... data to create a CleanupJobEvent
     *   }
     * })
     * 
     */
    create<T extends CleanupJobEventCreateArgs>(args: SelectSubset<T, CleanupJobEventCreateArgs<ExtArgs>>): Prisma__CleanupJobEventClient<$Result.GetResult<Prisma.$CleanupJobEventPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a CleanupJobEvent.
     * @param {CleanupJobEventDeleteArgs} args - Arguments to delete one CleanupJobEvent.
     * @example
     * // Delete one CleanupJobEvent
     * const CleanupJobEvent = await prisma.cleanupJobEvent.delete({
     *   where: {
     *     // ... filter to delete one CleanupJobEvent
     *   }
     * })
     * 
     */
    delete<T extends CleanupJobEventDeleteArgs>(args: SelectSubset<T, CleanupJobEventDeleteArgs<ExtArgs>>): Prisma__CleanupJobEventClient<$Result.GetResult<Prisma.$CleanupJobEventPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CleanupJobEvent.
   * 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__CleanupJobEventClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    job<T extends CleanupJobDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CleanupJobDefaultArgs<ExtArgs>>): Prisma__CleanupJobClient<$Result.GetResult<Prisma.$CleanupJobPayload<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 CleanupJobEvent model
   */ 
  interface CleanupJobEventFieldRefs {
    readonly id: FieldRef<"CleanupJobEvent", 'String'>
    readonly jobId: FieldRef<"CleanupJobEvent", 'String'>
    readonly level: FieldRef<"CleanupJobEvent", 'String'>
    readonly message: FieldRef<"CleanupJobEvent", 'String'>
    readonly progress: FieldRef<"CleanupJobEvent", 'Int'>
    readonly createdAt: FieldRef<"CleanupJobEvent", 'DateTime'>
  }
    

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

  /**
   * CleanupJobEvent findUniqueOrThrow
   */
  export type CleanupJobEventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    /**
     * Filter, which CleanupJobEvent to fetch.
     */
    where: CleanupJobEventWhereUniqueInput
  }

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

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

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

  /**
   * CleanupJobEvent create
   */
  export type CleanupJobEventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    /**
     * The data needed to create a CleanupJobEvent.
     */
    data: XOR<CleanupJobEventCreateInput, CleanupJobEventUncheckedCreateInput>
  }

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

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

  /**
   * CleanupJobEvent update
   */
  export type CleanupJobEventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    /**
     * The data needed to update a CleanupJobEvent.
     */
    data: XOR<CleanupJobEventUpdateInput, CleanupJobEventUncheckedUpdateInput>
    /**
     * Choose, which CleanupJobEvent to update.
     */
    where: CleanupJobEventWhereUniqueInput
  }

  /**
   * CleanupJobEvent updateMany
   */
  export type CleanupJobEventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CleanupJobEvents.
     */
    data: XOR<CleanupJobEventUpdateManyMutationInput, CleanupJobEventUncheckedUpdateManyInput>
    /**
     * Filter which CleanupJobEvents to update
     */
    where?: CleanupJobEventWhereInput
  }

  /**
   * CleanupJobEvent upsert
   */
  export type CleanupJobEventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    /**
     * The filter to search for the CleanupJobEvent to update in case it exists.
     */
    where: CleanupJobEventWhereUniqueInput
    /**
     * In case the CleanupJobEvent found by the `where` argument doesn't exist, create a new CleanupJobEvent with this data.
     */
    create: XOR<CleanupJobEventCreateInput, CleanupJobEventUncheckedCreateInput>
    /**
     * In case the CleanupJobEvent was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CleanupJobEventUpdateInput, CleanupJobEventUncheckedUpdateInput>
  }

  /**
   * CleanupJobEvent delete
   */
  export type CleanupJobEventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CleanupJobEvent
     */
    select?: CleanupJobEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CleanupJobEventInclude<ExtArgs> | null
    /**
     * Filter which CleanupJobEvent to delete.
     */
    where: CleanupJobEventWhereUniqueInput
  }

  /**
   * CleanupJobEvent deleteMany
   */
  export type CleanupJobEventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CleanupJobEvents to delete
     */
    where?: CleanupJobEventWhereInput
  }

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


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

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


  export const TenantScalarFieldEnum: {
    id: 'id',
    name: 'name',
    isActive: 'isActive',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const ExportJobScalarFieldEnum: {
    id: 'id',
    tenantId: 'tenantId',
    status: 'status',
    format: 'format',
    scope: 'scope',
    filePath: 'filePath',
    error: 'error',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const UserScalarFieldEnum: {
    id: 'id',
    tenantId: 'tenantId',
    email: 'email',
    password: 'password',
    role: 'role',
    isActive: 'isActive',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const MailboxAccountScalarFieldEnum: {
    id: 'id',
    tenantId: 'tenantId',
    email: 'email',
    provider: 'provider',
    isActive: 'isActive',
    imapHost: 'imapHost',
    imapPort: 'imapPort',
    imapTLS: 'imapTLS',
    smtpHost: 'smtpHost',
    smtpPort: 'smtpPort',
    smtpTLS: 'smtpTLS',
    oauthToken: 'oauthToken',
    oauthRefreshToken: 'oauthRefreshToken',
    oauthAccessToken: 'oauthAccessToken',
    oauthExpiresAt: 'oauthExpiresAt',
    providerUserId: 'providerUserId',
    appPassword: 'appPassword',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const MailboxFolderScalarFieldEnum: {
    id: 'id',
    mailboxAccountId: 'mailboxAccountId',
    name: 'name',
    remoteId: 'remoteId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const MailItemScalarFieldEnum: {
    id: 'id',
    folderId: 'folderId',
    messageId: 'messageId',
    subject: 'subject',
    from: 'from',
    receivedAt: 'receivedAt',
    listId: 'listId',
    listUnsubscribe: 'listUnsubscribe',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const RuleScalarFieldEnum: {
    id: 'id',
    tenantId: 'tenantId',
    name: 'name',
    enabled: 'enabled',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const RuleConditionScalarFieldEnum: {
    id: 'id',
    ruleId: 'ruleId',
    type: 'type',
    value: 'value'
  };

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


  export const RuleActionScalarFieldEnum: {
    id: 'id',
    ruleId: 'ruleId',
    type: 'type',
    target: 'target'
  };

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


  export const CleanupJobScalarFieldEnum: {
    id: 'id',
    tenantId: 'tenantId',
    mailboxAccountId: 'mailboxAccountId',
    status: 'status',
    dryRun: 'dryRun',
    unsubscribeEnabled: 'unsubscribeEnabled',
    routingEnabled: 'routingEnabled',
    startedAt: 'startedAt',
    finishedAt: 'finishedAt',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const UnsubscribeAttemptScalarFieldEnum: {
    id: 'id',
    jobId: 'jobId',
    mailItemId: 'mailItemId',
    method: 'method',
    target: 'target',
    status: 'status',
    createdAt: 'createdAt'
  };

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


  export const CleanupJobEventScalarFieldEnum: {
    id: 'id',
    jobId: 'jobId',
    level: 'level',
    message: 'message',
    progress: 'progress',
    createdAt: 'createdAt'
  };

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


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

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


  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]


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


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'ExportStatus'
   */
  export type EnumExportStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExportStatus'>
    


  /**
   * Reference to a field of type 'ExportStatus[]'
   */
  export type ListEnumExportStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExportStatus[]'>
    


  /**
   * 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 'MailProvider'
   */
  export type EnumMailProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MailProvider'>
    


  /**
   * Reference to a field of type 'MailProvider[]'
   */
  export type ListEnumMailProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MailProvider[]'>
    


  /**
   * 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 'RuleConditionType'
   */
  export type EnumRuleConditionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleConditionType'>
    


  /**
   * Reference to a field of type 'RuleConditionType[]'
   */
  export type ListEnumRuleConditionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleConditionType[]'>
    


  /**
   * Reference to a field of type 'RuleActionType'
   */
  export type EnumRuleActionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleActionType'>
    


  /**
   * Reference to a field of type 'RuleActionType[]'
   */
  export type ListEnumRuleActionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RuleActionType[]'>
    


  /**
   * Reference to a field of type 'JobStatus'
   */
  export type EnumJobStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'JobStatus'>
    


  /**
   * Reference to a field of type 'JobStatus[]'
   */
  export type ListEnumJobStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'JobStatus[]'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    
  /**
   * Deep Input Types
   */


  export type TenantWhereInput = {
    AND?: TenantWhereInput | TenantWhereInput[]
    OR?: TenantWhereInput[]
    NOT?: TenantWhereInput | TenantWhereInput[]
    id?: StringFilter<"Tenant"> | string
    name?: StringFilter<"Tenant"> | string
    isActive?: BoolFilter<"Tenant"> | boolean
    createdAt?: DateTimeFilter<"Tenant"> | Date | string
    updatedAt?: DateTimeFilter<"Tenant"> | Date | string
    exportJobs?: ExportJobListRelationFilter
    users?: UserListRelationFilter
    mailboxAccounts?: MailboxAccountListRelationFilter
    rules?: RuleListRelationFilter
    jobs?: CleanupJobListRelationFilter
  }

  export type TenantOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    exportJobs?: ExportJobOrderByRelationAggregateInput
    users?: UserOrderByRelationAggregateInput
    mailboxAccounts?: MailboxAccountOrderByRelationAggregateInput
    rules?: RuleOrderByRelationAggregateInput
    jobs?: CleanupJobOrderByRelationAggregateInput
  }

  export type TenantWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TenantWhereInput | TenantWhereInput[]
    OR?: TenantWhereInput[]
    NOT?: TenantWhereInput | TenantWhereInput[]
    name?: StringFilter<"Tenant"> | string
    isActive?: BoolFilter<"Tenant"> | boolean
    createdAt?: DateTimeFilter<"Tenant"> | Date | string
    updatedAt?: DateTimeFilter<"Tenant"> | Date | string
    exportJobs?: ExportJobListRelationFilter
    users?: UserListRelationFilter
    mailboxAccounts?: MailboxAccountListRelationFilter
    rules?: RuleListRelationFilter
    jobs?: CleanupJobListRelationFilter
  }, "id">

  export type TenantOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: TenantCountOrderByAggregateInput
    _max?: TenantMaxOrderByAggregateInput
    _min?: TenantMinOrderByAggregateInput
  }

  export type TenantScalarWhereWithAggregatesInput = {
    AND?: TenantScalarWhereWithAggregatesInput | TenantScalarWhereWithAggregatesInput[]
    OR?: TenantScalarWhereWithAggregatesInput[]
    NOT?: TenantScalarWhereWithAggregatesInput | TenantScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Tenant"> | string
    name?: StringWithAggregatesFilter<"Tenant"> | string
    isActive?: BoolWithAggregatesFilter<"Tenant"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Tenant"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Tenant"> | Date | string
  }

  export type ExportJobWhereInput = {
    AND?: ExportJobWhereInput | ExportJobWhereInput[]
    OR?: ExportJobWhereInput[]
    NOT?: ExportJobWhereInput | ExportJobWhereInput[]
    id?: StringFilter<"ExportJob"> | string
    tenantId?: StringFilter<"ExportJob"> | string
    status?: EnumExportStatusFilter<"ExportJob"> | $Enums.ExportStatus
    format?: StringFilter<"ExportJob"> | string
    scope?: StringFilter<"ExportJob"> | string
    filePath?: StringNullableFilter<"ExportJob"> | string | null
    error?: StringNullableFilter<"ExportJob"> | string | null
    createdAt?: DateTimeFilter<"ExportJob"> | Date | string
    updatedAt?: DateTimeFilter<"ExportJob"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
  }

  export type ExportJobOrderByWithRelationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    status?: SortOrder
    format?: SortOrder
    scope?: SortOrder
    filePath?: SortOrderInput | SortOrder
    error?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    tenant?: TenantOrderByWithRelationInput
  }

  export type ExportJobWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ExportJobWhereInput | ExportJobWhereInput[]
    OR?: ExportJobWhereInput[]
    NOT?: ExportJobWhereInput | ExportJobWhereInput[]
    tenantId?: StringFilter<"ExportJob"> | string
    status?: EnumExportStatusFilter<"ExportJob"> | $Enums.ExportStatus
    format?: StringFilter<"ExportJob"> | string
    scope?: StringFilter<"ExportJob"> | string
    filePath?: StringNullableFilter<"ExportJob"> | string | null
    error?: StringNullableFilter<"ExportJob"> | string | null
    createdAt?: DateTimeFilter<"ExportJob"> | Date | string
    updatedAt?: DateTimeFilter<"ExportJob"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
  }, "id">

  export type ExportJobOrderByWithAggregationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    status?: SortOrder
    format?: SortOrder
    scope?: SortOrder
    filePath?: SortOrderInput | SortOrder
    error?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: ExportJobCountOrderByAggregateInput
    _max?: ExportJobMaxOrderByAggregateInput
    _min?: ExportJobMinOrderByAggregateInput
  }

  export type ExportJobScalarWhereWithAggregatesInput = {
    AND?: ExportJobScalarWhereWithAggregatesInput | ExportJobScalarWhereWithAggregatesInput[]
    OR?: ExportJobScalarWhereWithAggregatesInput[]
    NOT?: ExportJobScalarWhereWithAggregatesInput | ExportJobScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ExportJob"> | string
    tenantId?: StringWithAggregatesFilter<"ExportJob"> | string
    status?: EnumExportStatusWithAggregatesFilter<"ExportJob"> | $Enums.ExportStatus
    format?: StringWithAggregatesFilter<"ExportJob"> | string
    scope?: StringWithAggregatesFilter<"ExportJob"> | string
    filePath?: StringNullableWithAggregatesFilter<"ExportJob"> | string | null
    error?: StringNullableWithAggregatesFilter<"ExportJob"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"ExportJob"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"ExportJob"> | Date | string
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    tenantId?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    isActive?: BoolFilter<"User"> | boolean
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    password?: SortOrder
    role?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    tenant?: TenantOrderByWithRelationInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    tenantId?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    isActive?: BoolFilter<"User"> | boolean
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    password?: SortOrder
    role?: SortOrder
    isActive?: 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
    tenantId?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    password?: StringWithAggregatesFilter<"User"> | string
    role?: EnumUserRoleWithAggregatesFilter<"User"> | $Enums.UserRole
    isActive?: BoolWithAggregatesFilter<"User"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type MailboxAccountWhereInput = {
    AND?: MailboxAccountWhereInput | MailboxAccountWhereInput[]
    OR?: MailboxAccountWhereInput[]
    NOT?: MailboxAccountWhereInput | MailboxAccountWhereInput[]
    id?: StringFilter<"MailboxAccount"> | string
    tenantId?: StringFilter<"MailboxAccount"> | string
    email?: StringFilter<"MailboxAccount"> | string
    provider?: EnumMailProviderFilter<"MailboxAccount"> | $Enums.MailProvider
    isActive?: BoolFilter<"MailboxAccount"> | boolean
    imapHost?: StringFilter<"MailboxAccount"> | string
    imapPort?: IntFilter<"MailboxAccount"> | number
    imapTLS?: BoolFilter<"MailboxAccount"> | boolean
    smtpHost?: StringNullableFilter<"MailboxAccount"> | string | null
    smtpPort?: IntNullableFilter<"MailboxAccount"> | number | null
    smtpTLS?: BoolNullableFilter<"MailboxAccount"> | boolean | null
    oauthToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthRefreshToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthAccessToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthExpiresAt?: DateTimeNullableFilter<"MailboxAccount"> | Date | string | null
    providerUserId?: StringNullableFilter<"MailboxAccount"> | string | null
    appPassword?: StringNullableFilter<"MailboxAccount"> | string | null
    createdAt?: DateTimeFilter<"MailboxAccount"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxAccount"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    folders?: MailboxFolderListRelationFilter
    jobs?: CleanupJobListRelationFilter
  }

  export type MailboxAccountOrderByWithRelationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    provider?: SortOrder
    isActive?: SortOrder
    imapHost?: SortOrder
    imapPort?: SortOrder
    imapTLS?: SortOrder
    smtpHost?: SortOrderInput | SortOrder
    smtpPort?: SortOrderInput | SortOrder
    smtpTLS?: SortOrderInput | SortOrder
    oauthToken?: SortOrderInput | SortOrder
    oauthRefreshToken?: SortOrderInput | SortOrder
    oauthAccessToken?: SortOrderInput | SortOrder
    oauthExpiresAt?: SortOrderInput | SortOrder
    providerUserId?: SortOrderInput | SortOrder
    appPassword?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    tenant?: TenantOrderByWithRelationInput
    folders?: MailboxFolderOrderByRelationAggregateInput
    jobs?: CleanupJobOrderByRelationAggregateInput
  }

  export type MailboxAccountWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MailboxAccountWhereInput | MailboxAccountWhereInput[]
    OR?: MailboxAccountWhereInput[]
    NOT?: MailboxAccountWhereInput | MailboxAccountWhereInput[]
    tenantId?: StringFilter<"MailboxAccount"> | string
    email?: StringFilter<"MailboxAccount"> | string
    provider?: EnumMailProviderFilter<"MailboxAccount"> | $Enums.MailProvider
    isActive?: BoolFilter<"MailboxAccount"> | boolean
    imapHost?: StringFilter<"MailboxAccount"> | string
    imapPort?: IntFilter<"MailboxAccount"> | number
    imapTLS?: BoolFilter<"MailboxAccount"> | boolean
    smtpHost?: StringNullableFilter<"MailboxAccount"> | string | null
    smtpPort?: IntNullableFilter<"MailboxAccount"> | number | null
    smtpTLS?: BoolNullableFilter<"MailboxAccount"> | boolean | null
    oauthToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthRefreshToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthAccessToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthExpiresAt?: DateTimeNullableFilter<"MailboxAccount"> | Date | string | null
    providerUserId?: StringNullableFilter<"MailboxAccount"> | string | null
    appPassword?: StringNullableFilter<"MailboxAccount"> | string | null
    createdAt?: DateTimeFilter<"MailboxAccount"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxAccount"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    folders?: MailboxFolderListRelationFilter
    jobs?: CleanupJobListRelationFilter
  }, "id">

  export type MailboxAccountOrderByWithAggregationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    provider?: SortOrder
    isActive?: SortOrder
    imapHost?: SortOrder
    imapPort?: SortOrder
    imapTLS?: SortOrder
    smtpHost?: SortOrderInput | SortOrder
    smtpPort?: SortOrderInput | SortOrder
    smtpTLS?: SortOrderInput | SortOrder
    oauthToken?: SortOrderInput | SortOrder
    oauthRefreshToken?: SortOrderInput | SortOrder
    oauthAccessToken?: SortOrderInput | SortOrder
    oauthExpiresAt?: SortOrderInput | SortOrder
    providerUserId?: SortOrderInput | SortOrder
    appPassword?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: MailboxAccountCountOrderByAggregateInput
    _avg?: MailboxAccountAvgOrderByAggregateInput
    _max?: MailboxAccountMaxOrderByAggregateInput
    _min?: MailboxAccountMinOrderByAggregateInput
    _sum?: MailboxAccountSumOrderByAggregateInput
  }

  export type MailboxAccountScalarWhereWithAggregatesInput = {
    AND?: MailboxAccountScalarWhereWithAggregatesInput | MailboxAccountScalarWhereWithAggregatesInput[]
    OR?: MailboxAccountScalarWhereWithAggregatesInput[]
    NOT?: MailboxAccountScalarWhereWithAggregatesInput | MailboxAccountScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MailboxAccount"> | string
    tenantId?: StringWithAggregatesFilter<"MailboxAccount"> | string
    email?: StringWithAggregatesFilter<"MailboxAccount"> | string
    provider?: EnumMailProviderWithAggregatesFilter<"MailboxAccount"> | $Enums.MailProvider
    isActive?: BoolWithAggregatesFilter<"MailboxAccount"> | boolean
    imapHost?: StringWithAggregatesFilter<"MailboxAccount"> | string
    imapPort?: IntWithAggregatesFilter<"MailboxAccount"> | number
    imapTLS?: BoolWithAggregatesFilter<"MailboxAccount"> | boolean
    smtpHost?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    smtpPort?: IntNullableWithAggregatesFilter<"MailboxAccount"> | number | null
    smtpTLS?: BoolNullableWithAggregatesFilter<"MailboxAccount"> | boolean | null
    oauthToken?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    oauthRefreshToken?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    oauthAccessToken?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    oauthExpiresAt?: DateTimeNullableWithAggregatesFilter<"MailboxAccount"> | Date | string | null
    providerUserId?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    appPassword?: StringNullableWithAggregatesFilter<"MailboxAccount"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"MailboxAccount"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"MailboxAccount"> | Date | string
  }

  export type MailboxFolderWhereInput = {
    AND?: MailboxFolderWhereInput | MailboxFolderWhereInput[]
    OR?: MailboxFolderWhereInput[]
    NOT?: MailboxFolderWhereInput | MailboxFolderWhereInput[]
    id?: StringFilter<"MailboxFolder"> | string
    mailboxAccountId?: StringFilter<"MailboxFolder"> | string
    name?: StringFilter<"MailboxFolder"> | string
    remoteId?: StringNullableFilter<"MailboxFolder"> | string | null
    createdAt?: DateTimeFilter<"MailboxFolder"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxFolder"> | Date | string
    mailboxAccount?: XOR<MailboxAccountRelationFilter, MailboxAccountWhereInput>
    mailItems?: MailItemListRelationFilter
  }

  export type MailboxFolderOrderByWithRelationInput = {
    id?: SortOrder
    mailboxAccountId?: SortOrder
    name?: SortOrder
    remoteId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    mailboxAccount?: MailboxAccountOrderByWithRelationInput
    mailItems?: MailItemOrderByRelationAggregateInput
  }

  export type MailboxFolderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MailboxFolderWhereInput | MailboxFolderWhereInput[]
    OR?: MailboxFolderWhereInput[]
    NOT?: MailboxFolderWhereInput | MailboxFolderWhereInput[]
    mailboxAccountId?: StringFilter<"MailboxFolder"> | string
    name?: StringFilter<"MailboxFolder"> | string
    remoteId?: StringNullableFilter<"MailboxFolder"> | string | null
    createdAt?: DateTimeFilter<"MailboxFolder"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxFolder"> | Date | string
    mailboxAccount?: XOR<MailboxAccountRelationFilter, MailboxAccountWhereInput>
    mailItems?: MailItemListRelationFilter
  }, "id">

  export type MailboxFolderOrderByWithAggregationInput = {
    id?: SortOrder
    mailboxAccountId?: SortOrder
    name?: SortOrder
    remoteId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: MailboxFolderCountOrderByAggregateInput
    _max?: MailboxFolderMaxOrderByAggregateInput
    _min?: MailboxFolderMinOrderByAggregateInput
  }

  export type MailboxFolderScalarWhereWithAggregatesInput = {
    AND?: MailboxFolderScalarWhereWithAggregatesInput | MailboxFolderScalarWhereWithAggregatesInput[]
    OR?: MailboxFolderScalarWhereWithAggregatesInput[]
    NOT?: MailboxFolderScalarWhereWithAggregatesInput | MailboxFolderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MailboxFolder"> | string
    mailboxAccountId?: StringWithAggregatesFilter<"MailboxFolder"> | string
    name?: StringWithAggregatesFilter<"MailboxFolder"> | string
    remoteId?: StringNullableWithAggregatesFilter<"MailboxFolder"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"MailboxFolder"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"MailboxFolder"> | Date | string
  }

  export type MailItemWhereInput = {
    AND?: MailItemWhereInput | MailItemWhereInput[]
    OR?: MailItemWhereInput[]
    NOT?: MailItemWhereInput | MailItemWhereInput[]
    id?: StringFilter<"MailItem"> | string
    folderId?: StringFilter<"MailItem"> | string
    messageId?: StringFilter<"MailItem"> | string
    subject?: StringNullableFilter<"MailItem"> | string | null
    from?: StringNullableFilter<"MailItem"> | string | null
    receivedAt?: DateTimeNullableFilter<"MailItem"> | Date | string | null
    listId?: StringNullableFilter<"MailItem"> | string | null
    listUnsubscribe?: StringNullableFilter<"MailItem"> | string | null
    createdAt?: DateTimeFilter<"MailItem"> | Date | string
    updatedAt?: DateTimeFilter<"MailItem"> | Date | string
    folder?: XOR<MailboxFolderRelationFilter, MailboxFolderWhereInput>
  }

  export type MailItemOrderByWithRelationInput = {
    id?: SortOrder
    folderId?: SortOrder
    messageId?: SortOrder
    subject?: SortOrderInput | SortOrder
    from?: SortOrderInput | SortOrder
    receivedAt?: SortOrderInput | SortOrder
    listId?: SortOrderInput | SortOrder
    listUnsubscribe?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    folder?: MailboxFolderOrderByWithRelationInput
  }

  export type MailItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MailItemWhereInput | MailItemWhereInput[]
    OR?: MailItemWhereInput[]
    NOT?: MailItemWhereInput | MailItemWhereInput[]
    folderId?: StringFilter<"MailItem"> | string
    messageId?: StringFilter<"MailItem"> | string
    subject?: StringNullableFilter<"MailItem"> | string | null
    from?: StringNullableFilter<"MailItem"> | string | null
    receivedAt?: DateTimeNullableFilter<"MailItem"> | Date | string | null
    listId?: StringNullableFilter<"MailItem"> | string | null
    listUnsubscribe?: StringNullableFilter<"MailItem"> | string | null
    createdAt?: DateTimeFilter<"MailItem"> | Date | string
    updatedAt?: DateTimeFilter<"MailItem"> | Date | string
    folder?: XOR<MailboxFolderRelationFilter, MailboxFolderWhereInput>
  }, "id">

  export type MailItemOrderByWithAggregationInput = {
    id?: SortOrder
    folderId?: SortOrder
    messageId?: SortOrder
    subject?: SortOrderInput | SortOrder
    from?: SortOrderInput | SortOrder
    receivedAt?: SortOrderInput | SortOrder
    listId?: SortOrderInput | SortOrder
    listUnsubscribe?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: MailItemCountOrderByAggregateInput
    _max?: MailItemMaxOrderByAggregateInput
    _min?: MailItemMinOrderByAggregateInput
  }

  export type MailItemScalarWhereWithAggregatesInput = {
    AND?: MailItemScalarWhereWithAggregatesInput | MailItemScalarWhereWithAggregatesInput[]
    OR?: MailItemScalarWhereWithAggregatesInput[]
    NOT?: MailItemScalarWhereWithAggregatesInput | MailItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MailItem"> | string
    folderId?: StringWithAggregatesFilter<"MailItem"> | string
    messageId?: StringWithAggregatesFilter<"MailItem"> | string
    subject?: StringNullableWithAggregatesFilter<"MailItem"> | string | null
    from?: StringNullableWithAggregatesFilter<"MailItem"> | string | null
    receivedAt?: DateTimeNullableWithAggregatesFilter<"MailItem"> | Date | string | null
    listId?: StringNullableWithAggregatesFilter<"MailItem"> | string | null
    listUnsubscribe?: StringNullableWithAggregatesFilter<"MailItem"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"MailItem"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"MailItem"> | Date | string
  }

  export type RuleWhereInput = {
    AND?: RuleWhereInput | RuleWhereInput[]
    OR?: RuleWhereInput[]
    NOT?: RuleWhereInput | RuleWhereInput[]
    id?: StringFilter<"Rule"> | string
    tenantId?: StringFilter<"Rule"> | string
    name?: StringFilter<"Rule"> | string
    enabled?: BoolFilter<"Rule"> | boolean
    createdAt?: DateTimeFilter<"Rule"> | Date | string
    updatedAt?: DateTimeFilter<"Rule"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    conditions?: RuleConditionListRelationFilter
    actions?: RuleActionListRelationFilter
  }

  export type RuleOrderByWithRelationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    name?: SortOrder
    enabled?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    tenant?: TenantOrderByWithRelationInput
    conditions?: RuleConditionOrderByRelationAggregateInput
    actions?: RuleActionOrderByRelationAggregateInput
  }

  export type RuleWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: RuleWhereInput | RuleWhereInput[]
    OR?: RuleWhereInput[]
    NOT?: RuleWhereInput | RuleWhereInput[]
    tenantId?: StringFilter<"Rule"> | string
    name?: StringFilter<"Rule"> | string
    enabled?: BoolFilter<"Rule"> | boolean
    createdAt?: DateTimeFilter<"Rule"> | Date | string
    updatedAt?: DateTimeFilter<"Rule"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    conditions?: RuleConditionListRelationFilter
    actions?: RuleActionListRelationFilter
  }, "id">

  export type RuleOrderByWithAggregationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    name?: SortOrder
    enabled?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: RuleCountOrderByAggregateInput
    _max?: RuleMaxOrderByAggregateInput
    _min?: RuleMinOrderByAggregateInput
  }

  export type RuleScalarWhereWithAggregatesInput = {
    AND?: RuleScalarWhereWithAggregatesInput | RuleScalarWhereWithAggregatesInput[]
    OR?: RuleScalarWhereWithAggregatesInput[]
    NOT?: RuleScalarWhereWithAggregatesInput | RuleScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Rule"> | string
    tenantId?: StringWithAggregatesFilter<"Rule"> | string
    name?: StringWithAggregatesFilter<"Rule"> | string
    enabled?: BoolWithAggregatesFilter<"Rule"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Rule"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Rule"> | Date | string
  }

  export type RuleConditionWhereInput = {
    AND?: RuleConditionWhereInput | RuleConditionWhereInput[]
    OR?: RuleConditionWhereInput[]
    NOT?: RuleConditionWhereInput | RuleConditionWhereInput[]
    id?: StringFilter<"RuleCondition"> | string
    ruleId?: StringFilter<"RuleCondition"> | string
    type?: EnumRuleConditionTypeFilter<"RuleCondition"> | $Enums.RuleConditionType
    value?: StringFilter<"RuleCondition"> | string
    rule?: XOR<RuleRelationFilter, RuleWhereInput>
  }

  export type RuleConditionOrderByWithRelationInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    rule?: RuleOrderByWithRelationInput
  }

  export type RuleConditionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: RuleConditionWhereInput | RuleConditionWhereInput[]
    OR?: RuleConditionWhereInput[]
    NOT?: RuleConditionWhereInput | RuleConditionWhereInput[]
    ruleId?: StringFilter<"RuleCondition"> | string
    type?: EnumRuleConditionTypeFilter<"RuleCondition"> | $Enums.RuleConditionType
    value?: StringFilter<"RuleCondition"> | string
    rule?: XOR<RuleRelationFilter, RuleWhereInput>
  }, "id">

  export type RuleConditionOrderByWithAggregationInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    value?: SortOrder
    _count?: RuleConditionCountOrderByAggregateInput
    _max?: RuleConditionMaxOrderByAggregateInput
    _min?: RuleConditionMinOrderByAggregateInput
  }

  export type RuleConditionScalarWhereWithAggregatesInput = {
    AND?: RuleConditionScalarWhereWithAggregatesInput | RuleConditionScalarWhereWithAggregatesInput[]
    OR?: RuleConditionScalarWhereWithAggregatesInput[]
    NOT?: RuleConditionScalarWhereWithAggregatesInput | RuleConditionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"RuleCondition"> | string
    ruleId?: StringWithAggregatesFilter<"RuleCondition"> | string
    type?: EnumRuleConditionTypeWithAggregatesFilter<"RuleCondition"> | $Enums.RuleConditionType
    value?: StringWithAggregatesFilter<"RuleCondition"> | string
  }

  export type RuleActionWhereInput = {
    AND?: RuleActionWhereInput | RuleActionWhereInput[]
    OR?: RuleActionWhereInput[]
    NOT?: RuleActionWhereInput | RuleActionWhereInput[]
    id?: StringFilter<"RuleAction"> | string
    ruleId?: StringFilter<"RuleAction"> | string
    type?: EnumRuleActionTypeFilter<"RuleAction"> | $Enums.RuleActionType
    target?: StringNullableFilter<"RuleAction"> | string | null
    rule?: XOR<RuleRelationFilter, RuleWhereInput>
  }

  export type RuleActionOrderByWithRelationInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    target?: SortOrderInput | SortOrder
    rule?: RuleOrderByWithRelationInput
  }

  export type RuleActionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: RuleActionWhereInput | RuleActionWhereInput[]
    OR?: RuleActionWhereInput[]
    NOT?: RuleActionWhereInput | RuleActionWhereInput[]
    ruleId?: StringFilter<"RuleAction"> | string
    type?: EnumRuleActionTypeFilter<"RuleAction"> | $Enums.RuleActionType
    target?: StringNullableFilter<"RuleAction"> | string | null
    rule?: XOR<RuleRelationFilter, RuleWhereInput>
  }, "id">

  export type RuleActionOrderByWithAggregationInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    target?: SortOrderInput | SortOrder
    _count?: RuleActionCountOrderByAggregateInput
    _max?: RuleActionMaxOrderByAggregateInput
    _min?: RuleActionMinOrderByAggregateInput
  }

  export type RuleActionScalarWhereWithAggregatesInput = {
    AND?: RuleActionScalarWhereWithAggregatesInput | RuleActionScalarWhereWithAggregatesInput[]
    OR?: RuleActionScalarWhereWithAggregatesInput[]
    NOT?: RuleActionScalarWhereWithAggregatesInput | RuleActionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"RuleAction"> | string
    ruleId?: StringWithAggregatesFilter<"RuleAction"> | string
    type?: EnumRuleActionTypeWithAggregatesFilter<"RuleAction"> | $Enums.RuleActionType
    target?: StringNullableWithAggregatesFilter<"RuleAction"> | string | null
  }

  export type CleanupJobWhereInput = {
    AND?: CleanupJobWhereInput | CleanupJobWhereInput[]
    OR?: CleanupJobWhereInput[]
    NOT?: CleanupJobWhereInput | CleanupJobWhereInput[]
    id?: StringFilter<"CleanupJob"> | string
    tenantId?: StringFilter<"CleanupJob"> | string
    mailboxAccountId?: StringFilter<"CleanupJob"> | string
    status?: EnumJobStatusFilter<"CleanupJob"> | $Enums.JobStatus
    dryRun?: BoolFilter<"CleanupJob"> | boolean
    unsubscribeEnabled?: BoolFilter<"CleanupJob"> | boolean
    routingEnabled?: BoolFilter<"CleanupJob"> | boolean
    startedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    finishedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    createdAt?: DateTimeFilter<"CleanupJob"> | Date | string
    updatedAt?: DateTimeFilter<"CleanupJob"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    mailboxAccount?: XOR<MailboxAccountRelationFilter, MailboxAccountWhereInput>
    unsubscribeAttempts?: UnsubscribeAttemptListRelationFilter
    events?: CleanupJobEventListRelationFilter
  }

  export type CleanupJobOrderByWithRelationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    mailboxAccountId?: SortOrder
    status?: SortOrder
    dryRun?: SortOrder
    unsubscribeEnabled?: SortOrder
    routingEnabled?: SortOrder
    startedAt?: SortOrderInput | SortOrder
    finishedAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    tenant?: TenantOrderByWithRelationInput
    mailboxAccount?: MailboxAccountOrderByWithRelationInput
    unsubscribeAttempts?: UnsubscribeAttemptOrderByRelationAggregateInput
    events?: CleanupJobEventOrderByRelationAggregateInput
  }

  export type CleanupJobWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CleanupJobWhereInput | CleanupJobWhereInput[]
    OR?: CleanupJobWhereInput[]
    NOT?: CleanupJobWhereInput | CleanupJobWhereInput[]
    tenantId?: StringFilter<"CleanupJob"> | string
    mailboxAccountId?: StringFilter<"CleanupJob"> | string
    status?: EnumJobStatusFilter<"CleanupJob"> | $Enums.JobStatus
    dryRun?: BoolFilter<"CleanupJob"> | boolean
    unsubscribeEnabled?: BoolFilter<"CleanupJob"> | boolean
    routingEnabled?: BoolFilter<"CleanupJob"> | boolean
    startedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    finishedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    createdAt?: DateTimeFilter<"CleanupJob"> | Date | string
    updatedAt?: DateTimeFilter<"CleanupJob"> | Date | string
    tenant?: XOR<TenantRelationFilter, TenantWhereInput>
    mailboxAccount?: XOR<MailboxAccountRelationFilter, MailboxAccountWhereInput>
    unsubscribeAttempts?: UnsubscribeAttemptListRelationFilter
    events?: CleanupJobEventListRelationFilter
  }, "id">

  export type CleanupJobOrderByWithAggregationInput = {
    id?: SortOrder
    tenantId?: SortOrder
    mailboxAccountId?: SortOrder
    status?: SortOrder
    dryRun?: SortOrder
    unsubscribeEnabled?: SortOrder
    routingEnabled?: SortOrder
    startedAt?: SortOrderInput | SortOrder
    finishedAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: CleanupJobCountOrderByAggregateInput
    _max?: CleanupJobMaxOrderByAggregateInput
    _min?: CleanupJobMinOrderByAggregateInput
  }

  export type CleanupJobScalarWhereWithAggregatesInput = {
    AND?: CleanupJobScalarWhereWithAggregatesInput | CleanupJobScalarWhereWithAggregatesInput[]
    OR?: CleanupJobScalarWhereWithAggregatesInput[]
    NOT?: CleanupJobScalarWhereWithAggregatesInput | CleanupJobScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"CleanupJob"> | string
    tenantId?: StringWithAggregatesFilter<"CleanupJob"> | string
    mailboxAccountId?: StringWithAggregatesFilter<"CleanupJob"> | string
    status?: EnumJobStatusWithAggregatesFilter<"CleanupJob"> | $Enums.JobStatus
    dryRun?: BoolWithAggregatesFilter<"CleanupJob"> | boolean
    unsubscribeEnabled?: BoolWithAggregatesFilter<"CleanupJob"> | boolean
    routingEnabled?: BoolWithAggregatesFilter<"CleanupJob"> | boolean
    startedAt?: DateTimeNullableWithAggregatesFilter<"CleanupJob"> | Date | string | null
    finishedAt?: DateTimeNullableWithAggregatesFilter<"CleanupJob"> | Date | string | null
    createdAt?: DateTimeWithAggregatesFilter<"CleanupJob"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"CleanupJob"> | Date | string
  }

  export type UnsubscribeAttemptWhereInput = {
    AND?: UnsubscribeAttemptWhereInput | UnsubscribeAttemptWhereInput[]
    OR?: UnsubscribeAttemptWhereInput[]
    NOT?: UnsubscribeAttemptWhereInput | UnsubscribeAttemptWhereInput[]
    id?: StringFilter<"UnsubscribeAttempt"> | string
    jobId?: StringFilter<"UnsubscribeAttempt"> | string
    mailItemId?: StringNullableFilter<"UnsubscribeAttempt"> | string | null
    method?: StringFilter<"UnsubscribeAttempt"> | string
    target?: StringFilter<"UnsubscribeAttempt"> | string
    status?: StringFilter<"UnsubscribeAttempt"> | string
    createdAt?: DateTimeFilter<"UnsubscribeAttempt"> | Date | string
    job?: XOR<CleanupJobRelationFilter, CleanupJobWhereInput>
  }

  export type UnsubscribeAttemptOrderByWithRelationInput = {
    id?: SortOrder
    jobId?: SortOrder
    mailItemId?: SortOrderInput | SortOrder
    method?: SortOrder
    target?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    job?: CleanupJobOrderByWithRelationInput
  }

  export type UnsubscribeAttemptWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UnsubscribeAttemptWhereInput | UnsubscribeAttemptWhereInput[]
    OR?: UnsubscribeAttemptWhereInput[]
    NOT?: UnsubscribeAttemptWhereInput | UnsubscribeAttemptWhereInput[]
    jobId?: StringFilter<"UnsubscribeAttempt"> | string
    mailItemId?: StringNullableFilter<"UnsubscribeAttempt"> | string | null
    method?: StringFilter<"UnsubscribeAttempt"> | string
    target?: StringFilter<"UnsubscribeAttempt"> | string
    status?: StringFilter<"UnsubscribeAttempt"> | string
    createdAt?: DateTimeFilter<"UnsubscribeAttempt"> | Date | string
    job?: XOR<CleanupJobRelationFilter, CleanupJobWhereInput>
  }, "id">

  export type UnsubscribeAttemptOrderByWithAggregationInput = {
    id?: SortOrder
    jobId?: SortOrder
    mailItemId?: SortOrderInput | SortOrder
    method?: SortOrder
    target?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    _count?: UnsubscribeAttemptCountOrderByAggregateInput
    _max?: UnsubscribeAttemptMaxOrderByAggregateInput
    _min?: UnsubscribeAttemptMinOrderByAggregateInput
  }

  export type UnsubscribeAttemptScalarWhereWithAggregatesInput = {
    AND?: UnsubscribeAttemptScalarWhereWithAggregatesInput | UnsubscribeAttemptScalarWhereWithAggregatesInput[]
    OR?: UnsubscribeAttemptScalarWhereWithAggregatesInput[]
    NOT?: UnsubscribeAttemptScalarWhereWithAggregatesInput | UnsubscribeAttemptScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UnsubscribeAttempt"> | string
    jobId?: StringWithAggregatesFilter<"UnsubscribeAttempt"> | string
    mailItemId?: StringNullableWithAggregatesFilter<"UnsubscribeAttempt"> | string | null
    method?: StringWithAggregatesFilter<"UnsubscribeAttempt"> | string
    target?: StringWithAggregatesFilter<"UnsubscribeAttempt"> | string
    status?: StringWithAggregatesFilter<"UnsubscribeAttempt"> | string
    createdAt?: DateTimeWithAggregatesFilter<"UnsubscribeAttempt"> | Date | string
  }

  export type CleanupJobEventWhereInput = {
    AND?: CleanupJobEventWhereInput | CleanupJobEventWhereInput[]
    OR?: CleanupJobEventWhereInput[]
    NOT?: CleanupJobEventWhereInput | CleanupJobEventWhereInput[]
    id?: StringFilter<"CleanupJobEvent"> | string
    jobId?: StringFilter<"CleanupJobEvent"> | string
    level?: StringFilter<"CleanupJobEvent"> | string
    message?: StringFilter<"CleanupJobEvent"> | string
    progress?: IntNullableFilter<"CleanupJobEvent"> | number | null
    createdAt?: DateTimeFilter<"CleanupJobEvent"> | Date | string
    job?: XOR<CleanupJobRelationFilter, CleanupJobWhereInput>
  }

  export type CleanupJobEventOrderByWithRelationInput = {
    id?: SortOrder
    jobId?: SortOrder
    level?: SortOrder
    message?: SortOrder
    progress?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    job?: CleanupJobOrderByWithRelationInput
  }

  export type CleanupJobEventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CleanupJobEventWhereInput | CleanupJobEventWhereInput[]
    OR?: CleanupJobEventWhereInput[]
    NOT?: CleanupJobEventWhereInput | CleanupJobEventWhereInput[]
    jobId?: StringFilter<"CleanupJobEvent"> | string
    level?: StringFilter<"CleanupJobEvent"> | string
    message?: StringFilter<"CleanupJobEvent"> | string
    progress?: IntNullableFilter<"CleanupJobEvent"> | number | null
    createdAt?: DateTimeFilter<"CleanupJobEvent"> | Date | string
    job?: XOR<CleanupJobRelationFilter, CleanupJobWhereInput>
  }, "id">

  export type CleanupJobEventOrderByWithAggregationInput = {
    id?: SortOrder
    jobId?: SortOrder
    level?: SortOrder
    message?: SortOrder
    progress?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: CleanupJobEventCountOrderByAggregateInput
    _avg?: CleanupJobEventAvgOrderByAggregateInput
    _max?: CleanupJobEventMaxOrderByAggregateInput
    _min?: CleanupJobEventMinOrderByAggregateInput
    _sum?: CleanupJobEventSumOrderByAggregateInput
  }

  export type CleanupJobEventScalarWhereWithAggregatesInput = {
    AND?: CleanupJobEventScalarWhereWithAggregatesInput | CleanupJobEventScalarWhereWithAggregatesInput[]
    OR?: CleanupJobEventScalarWhereWithAggregatesInput[]
    NOT?: CleanupJobEventScalarWhereWithAggregatesInput | CleanupJobEventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"CleanupJobEvent"> | string
    jobId?: StringWithAggregatesFilter<"CleanupJobEvent"> | string
    level?: StringWithAggregatesFilter<"CleanupJobEvent"> | string
    message?: StringWithAggregatesFilter<"CleanupJobEvent"> | string
    progress?: IntNullableWithAggregatesFilter<"CleanupJobEvent"> | number | null
    createdAt?: DateTimeWithAggregatesFilter<"CleanupJobEvent"> | Date | string
  }

  export type TenantCreateInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobCreateNestedManyWithoutTenantInput
    users?: UserCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountCreateNestedManyWithoutTenantInput
    rules?: RuleCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobUncheckedCreateNestedManyWithoutTenantInput
    users?: UserUncheckedCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountUncheckedCreateNestedManyWithoutTenantInput
    rules?: RuleUncheckedCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUpdateManyWithoutTenantNestedInput
    users?: UserUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUpdateManyWithoutTenantNestedInput
    rules?: RuleUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUncheckedUpdateManyWithoutTenantNestedInput
    users?: UserUncheckedUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput
    rules?: RuleUncheckedUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type TenantCreateManyInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type TenantUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TenantUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExportJobCreateInput = {
    id?: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutExportJobsInput
  }

  export type ExportJobUncheckedCreateInput = {
    id?: string
    tenantId: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExportJobUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutExportJobsNestedInput
  }

  export type ExportJobUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExportJobCreateManyInput = {
    id?: string
    tenantId: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExportJobUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExportJobUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateInput = {
    id?: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutUsersInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    tenantId: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutUsersNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateManyInput = {
    id?: string
    tenantId: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxAccountCreateInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutMailboxAccountsInput
    folders?: MailboxFolderCreateNestedManyWithoutMailboxAccountInput
    jobs?: CleanupJobCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountUncheckedCreateInput = {
    id?: string
    tenantId: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folders?: MailboxFolderUncheckedCreateNestedManyWithoutMailboxAccountInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutMailboxAccountsNestedInput
    folders?: MailboxFolderUpdateManyWithoutMailboxAccountNestedInput
    jobs?: CleanupJobUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folders?: MailboxFolderUncheckedUpdateManyWithoutMailboxAccountNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountCreateManyInput = {
    id?: string
    tenantId: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailboxAccountUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxAccountUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxFolderCreateInput = {
    id?: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailboxAccount: MailboxAccountCreateNestedOneWithoutFoldersInput
    mailItems?: MailItemCreateNestedManyWithoutFolderInput
  }

  export type MailboxFolderUncheckedCreateInput = {
    id?: string
    mailboxAccountId: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailItems?: MailItemUncheckedCreateNestedManyWithoutFolderInput
  }

  export type MailboxFolderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutFoldersNestedInput
    mailItems?: MailItemUpdateManyWithoutFolderNestedInput
  }

  export type MailboxFolderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailItems?: MailItemUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type MailboxFolderCreateManyInput = {
    id?: string
    mailboxAccountId: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailboxFolderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxFolderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemCreateInput = {
    id?: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folder: MailboxFolderCreateNestedOneWithoutMailItemsInput
  }

  export type MailItemUncheckedCreateInput = {
    id?: string
    folderId: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folder?: MailboxFolderUpdateOneRequiredWithoutMailItemsNestedInput
  }

  export type MailItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    folderId?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemCreateManyInput = {
    id?: string
    folderId: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    folderId?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RuleCreateInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutRulesInput
    conditions?: RuleConditionCreateNestedManyWithoutRuleInput
    actions?: RuleActionCreateNestedManyWithoutRuleInput
  }

  export type RuleUncheckedCreateInput = {
    id?: string
    tenantId: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    conditions?: RuleConditionUncheckedCreateNestedManyWithoutRuleInput
    actions?: RuleActionUncheckedCreateNestedManyWithoutRuleInput
  }

  export type RuleUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutRulesNestedInput
    conditions?: RuleConditionUpdateManyWithoutRuleNestedInput
    actions?: RuleActionUpdateManyWithoutRuleNestedInput
  }

  export type RuleUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    conditions?: RuleConditionUncheckedUpdateManyWithoutRuleNestedInput
    actions?: RuleActionUncheckedUpdateManyWithoutRuleNestedInput
  }

  export type RuleCreateManyInput = {
    id?: string
    tenantId: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type RuleUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RuleUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RuleConditionCreateInput = {
    id?: string
    type: $Enums.RuleConditionType
    value: string
    rule: RuleCreateNestedOneWithoutConditionsInput
  }

  export type RuleConditionUncheckedCreateInput = {
    id?: string
    ruleId: string
    type: $Enums.RuleConditionType
    value: string
  }

  export type RuleConditionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
    rule?: RuleUpdateOneRequiredWithoutConditionsNestedInput
  }

  export type RuleConditionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    ruleId?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleConditionCreateManyInput = {
    id?: string
    ruleId: string
    type: $Enums.RuleConditionType
    value: string
  }

  export type RuleConditionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleConditionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    ruleId?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleActionCreateInput = {
    id?: string
    type: $Enums.RuleActionType
    target?: string | null
    rule: RuleCreateNestedOneWithoutActionsInput
  }

  export type RuleActionUncheckedCreateInput = {
    id?: string
    ruleId: string
    type: $Enums.RuleActionType
    target?: string | null
  }

  export type RuleActionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
    rule?: RuleUpdateOneRequiredWithoutActionsNestedInput
  }

  export type RuleActionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    ruleId?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RuleActionCreateManyInput = {
    id?: string
    ruleId: string
    type: $Enums.RuleActionType
    target?: string | null
  }

  export type RuleActionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RuleActionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    ruleId?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CleanupJobCreateInput = {
    id?: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutJobsInput
    mailboxAccount: MailboxAccountCreateNestedOneWithoutJobsInput
    unsubscribeAttempts?: UnsubscribeAttemptCreateNestedManyWithoutJobInput
    events?: CleanupJobEventCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUncheckedCreateInput = {
    id?: string
    tenantId: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedCreateNestedManyWithoutJobInput
    events?: CleanupJobEventUncheckedCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutJobsNestedInput
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutJobsNestedInput
    unsubscribeAttempts?: UnsubscribeAttemptUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUncheckedUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobCreateManyInput = {
    id?: string
    tenantId: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CleanupJobUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UnsubscribeAttemptCreateInput = {
    id?: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
    job: CleanupJobCreateNestedOneWithoutUnsubscribeAttemptsInput
  }

  export type UnsubscribeAttemptUncheckedCreateInput = {
    id?: string
    jobId: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
  }

  export type UnsubscribeAttemptUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    job?: CleanupJobUpdateOneRequiredWithoutUnsubscribeAttemptsNestedInput
  }

  export type UnsubscribeAttemptUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jobId?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UnsubscribeAttemptCreateManyInput = {
    id?: string
    jobId: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
  }

  export type UnsubscribeAttemptUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UnsubscribeAttemptUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    jobId?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventCreateInput = {
    id?: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
    job: CleanupJobCreateNestedOneWithoutEventsInput
  }

  export type CleanupJobEventUncheckedCreateInput = {
    id?: string
    jobId: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
  }

  export type CleanupJobEventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    job?: CleanupJobUpdateOneRequiredWithoutEventsNestedInput
  }

  export type CleanupJobEventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jobId?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventCreateManyInput = {
    id?: string
    jobId: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
  }

  export type CleanupJobEventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    jobId?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    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 BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  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 ExportJobListRelationFilter = {
    every?: ExportJobWhereInput
    some?: ExportJobWhereInput
    none?: ExportJobWhereInput
  }

  export type UserListRelationFilter = {
    every?: UserWhereInput
    some?: UserWhereInput
    none?: UserWhereInput
  }

  export type MailboxAccountListRelationFilter = {
    every?: MailboxAccountWhereInput
    some?: MailboxAccountWhereInput
    none?: MailboxAccountWhereInput
  }

  export type RuleListRelationFilter = {
    every?: RuleWhereInput
    some?: RuleWhereInput
    none?: RuleWhereInput
  }

  export type CleanupJobListRelationFilter = {
    every?: CleanupJobWhereInput
    some?: CleanupJobWhereInput
    none?: CleanupJobWhereInput
  }

  export type ExportJobOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MailboxAccountOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RuleOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CleanupJobOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TenantCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type TenantMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type TenantMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    isActive?: 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 BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$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 EnumExportStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ExportStatus | EnumExportStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumExportStatusFilter<$PrismaModel> | $Enums.ExportStatus
  }

  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 TenantRelationFilter = {
    is?: TenantWhereInput
    isNot?: TenantWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type ExportJobCountOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    status?: SortOrder
    format?: SortOrder
    scope?: SortOrder
    filePath?: SortOrder
    error?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ExportJobMaxOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    status?: SortOrder
    format?: SortOrder
    scope?: SortOrder
    filePath?: SortOrder
    error?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ExportJobMinOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    status?: SortOrder
    format?: SortOrder
    scope?: SortOrder
    filePath?: SortOrder
    error?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumExportStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExportStatus | EnumExportStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumExportStatusWithAggregatesFilter<$PrismaModel> | $Enums.ExportStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExportStatusFilter<$PrismaModel>
    _max?: NestedEnumExportStatusFilter<$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 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 UserCountOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    password?: SortOrder
    role?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    password?: SortOrder
    role?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    password?: SortOrder
    role?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  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 EnumMailProviderFilter<$PrismaModel = never> = {
    equals?: $Enums.MailProvider | EnumMailProviderFieldRefInput<$PrismaModel>
    in?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumMailProviderFilter<$PrismaModel> | $Enums.MailProvider
  }

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

  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 MailboxFolderListRelationFilter = {
    every?: MailboxFolderWhereInput
    some?: MailboxFolderWhereInput
    none?: MailboxFolderWhereInput
  }

  export type MailboxFolderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MailboxAccountCountOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    provider?: SortOrder
    isActive?: SortOrder
    imapHost?: SortOrder
    imapPort?: SortOrder
    imapTLS?: SortOrder
    smtpHost?: SortOrder
    smtpPort?: SortOrder
    smtpTLS?: SortOrder
    oauthToken?: SortOrder
    oauthRefreshToken?: SortOrder
    oauthAccessToken?: SortOrder
    oauthExpiresAt?: SortOrder
    providerUserId?: SortOrder
    appPassword?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxAccountAvgOrderByAggregateInput = {
    imapPort?: SortOrder
    smtpPort?: SortOrder
  }

  export type MailboxAccountMaxOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    provider?: SortOrder
    isActive?: SortOrder
    imapHost?: SortOrder
    imapPort?: SortOrder
    imapTLS?: SortOrder
    smtpHost?: SortOrder
    smtpPort?: SortOrder
    smtpTLS?: SortOrder
    oauthToken?: SortOrder
    oauthRefreshToken?: SortOrder
    oauthAccessToken?: SortOrder
    oauthExpiresAt?: SortOrder
    providerUserId?: SortOrder
    appPassword?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxAccountMinOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    email?: SortOrder
    provider?: SortOrder
    isActive?: SortOrder
    imapHost?: SortOrder
    imapPort?: SortOrder
    imapTLS?: SortOrder
    smtpHost?: SortOrder
    smtpPort?: SortOrder
    smtpTLS?: SortOrder
    oauthToken?: SortOrder
    oauthRefreshToken?: SortOrder
    oauthAccessToken?: SortOrder
    oauthExpiresAt?: SortOrder
    providerUserId?: SortOrder
    appPassword?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxAccountSumOrderByAggregateInput = {
    imapPort?: SortOrder
    smtpPort?: SortOrder
  }

  export type EnumMailProviderWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MailProvider | EnumMailProviderFieldRefInput<$PrismaModel>
    in?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumMailProviderWithAggregatesFilter<$PrismaModel> | $Enums.MailProvider
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMailProviderFilter<$PrismaModel>
    _max?: NestedEnumMailProviderFilter<$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 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 BoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$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 MailboxAccountRelationFilter = {
    is?: MailboxAccountWhereInput
    isNot?: MailboxAccountWhereInput
  }

  export type MailItemListRelationFilter = {
    every?: MailItemWhereInput
    some?: MailItemWhereInput
    none?: MailItemWhereInput
  }

  export type MailItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MailboxFolderCountOrderByAggregateInput = {
    id?: SortOrder
    mailboxAccountId?: SortOrder
    name?: SortOrder
    remoteId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxFolderMaxOrderByAggregateInput = {
    id?: SortOrder
    mailboxAccountId?: SortOrder
    name?: SortOrder
    remoteId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxFolderMinOrderByAggregateInput = {
    id?: SortOrder
    mailboxAccountId?: SortOrder
    name?: SortOrder
    remoteId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailboxFolderRelationFilter = {
    is?: MailboxFolderWhereInput
    isNot?: MailboxFolderWhereInput
  }

  export type MailItemCountOrderByAggregateInput = {
    id?: SortOrder
    folderId?: SortOrder
    messageId?: SortOrder
    subject?: SortOrder
    from?: SortOrder
    receivedAt?: SortOrder
    listId?: SortOrder
    listUnsubscribe?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailItemMaxOrderByAggregateInput = {
    id?: SortOrder
    folderId?: SortOrder
    messageId?: SortOrder
    subject?: SortOrder
    from?: SortOrder
    receivedAt?: SortOrder
    listId?: SortOrder
    listUnsubscribe?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type MailItemMinOrderByAggregateInput = {
    id?: SortOrder
    folderId?: SortOrder
    messageId?: SortOrder
    subject?: SortOrder
    from?: SortOrder
    receivedAt?: SortOrder
    listId?: SortOrder
    listUnsubscribe?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type RuleConditionListRelationFilter = {
    every?: RuleConditionWhereInput
    some?: RuleConditionWhereInput
    none?: RuleConditionWhereInput
  }

  export type RuleActionListRelationFilter = {
    every?: RuleActionWhereInput
    some?: RuleActionWhereInput
    none?: RuleActionWhereInput
  }

  export type RuleConditionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RuleActionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RuleCountOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    name?: SortOrder
    enabled?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type RuleMaxOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    name?: SortOrder
    enabled?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type RuleMinOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    name?: SortOrder
    enabled?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumRuleConditionTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleConditionType | EnumRuleConditionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleConditionTypeFilter<$PrismaModel> | $Enums.RuleConditionType
  }

  export type RuleRelationFilter = {
    is?: RuleWhereInput
    isNot?: RuleWhereInput
  }

  export type RuleConditionCountOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    value?: SortOrder
  }

  export type RuleConditionMaxOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    value?: SortOrder
  }

  export type RuleConditionMinOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    value?: SortOrder
  }

  export type EnumRuleConditionTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleConditionType | EnumRuleConditionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleConditionTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleConditionType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleConditionTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleConditionTypeFilter<$PrismaModel>
  }

  export type EnumRuleActionTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleActionType | EnumRuleActionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionTypeFilter<$PrismaModel> | $Enums.RuleActionType
  }

  export type RuleActionCountOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    target?: SortOrder
  }

  export type RuleActionMaxOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    target?: SortOrder
  }

  export type RuleActionMinOrderByAggregateInput = {
    id?: SortOrder
    ruleId?: SortOrder
    type?: SortOrder
    target?: SortOrder
  }

  export type EnumRuleActionTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleActionType | EnumRuleActionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleActionType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleActionTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleActionTypeFilter<$PrismaModel>
  }

  export type EnumJobStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.JobStatus | EnumJobStatusFieldRefInput<$PrismaModel>
    in?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumJobStatusFilter<$PrismaModel> | $Enums.JobStatus
  }

  export type UnsubscribeAttemptListRelationFilter = {
    every?: UnsubscribeAttemptWhereInput
    some?: UnsubscribeAttemptWhereInput
    none?: UnsubscribeAttemptWhereInput
  }

  export type CleanupJobEventListRelationFilter = {
    every?: CleanupJobEventWhereInput
    some?: CleanupJobEventWhereInput
    none?: CleanupJobEventWhereInput
  }

  export type UnsubscribeAttemptOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CleanupJobEventOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CleanupJobCountOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    mailboxAccountId?: SortOrder
    status?: SortOrder
    dryRun?: SortOrder
    unsubscribeEnabled?: SortOrder
    routingEnabled?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CleanupJobMaxOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    mailboxAccountId?: SortOrder
    status?: SortOrder
    dryRun?: SortOrder
    unsubscribeEnabled?: SortOrder
    routingEnabled?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CleanupJobMinOrderByAggregateInput = {
    id?: SortOrder
    tenantId?: SortOrder
    mailboxAccountId?: SortOrder
    status?: SortOrder
    dryRun?: SortOrder
    unsubscribeEnabled?: SortOrder
    routingEnabled?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumJobStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.JobStatus | EnumJobStatusFieldRefInput<$PrismaModel>
    in?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumJobStatusWithAggregatesFilter<$PrismaModel> | $Enums.JobStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumJobStatusFilter<$PrismaModel>
    _max?: NestedEnumJobStatusFilter<$PrismaModel>
  }

  export type CleanupJobRelationFilter = {
    is?: CleanupJobWhereInput
    isNot?: CleanupJobWhereInput
  }

  export type UnsubscribeAttemptCountOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    mailItemId?: SortOrder
    method?: SortOrder
    target?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type UnsubscribeAttemptMaxOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    mailItemId?: SortOrder
    method?: SortOrder
    target?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type UnsubscribeAttemptMinOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    mailItemId?: SortOrder
    method?: SortOrder
    target?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type CleanupJobEventCountOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    level?: SortOrder
    message?: SortOrder
    progress?: SortOrder
    createdAt?: SortOrder
  }

  export type CleanupJobEventAvgOrderByAggregateInput = {
    progress?: SortOrder
  }

  export type CleanupJobEventMaxOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    level?: SortOrder
    message?: SortOrder
    progress?: SortOrder
    createdAt?: SortOrder
  }

  export type CleanupJobEventMinOrderByAggregateInput = {
    id?: SortOrder
    jobId?: SortOrder
    level?: SortOrder
    message?: SortOrder
    progress?: SortOrder
    createdAt?: SortOrder
  }

  export type CleanupJobEventSumOrderByAggregateInput = {
    progress?: SortOrder
  }

  export type ExportJobCreateNestedManyWithoutTenantInput = {
    create?: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput> | ExportJobCreateWithoutTenantInput[] | ExportJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: ExportJobCreateOrConnectWithoutTenantInput | ExportJobCreateOrConnectWithoutTenantInput[]
    createMany?: ExportJobCreateManyTenantInputEnvelope
    connect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
  }

  export type UserCreateNestedManyWithoutTenantInput = {
    create?: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput> | UserCreateWithoutTenantInput[] | UserUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: UserCreateOrConnectWithoutTenantInput | UserCreateOrConnectWithoutTenantInput[]
    createMany?: UserCreateManyTenantInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type MailboxAccountCreateNestedManyWithoutTenantInput = {
    create?: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput> | MailboxAccountCreateWithoutTenantInput[] | MailboxAccountUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutTenantInput | MailboxAccountCreateOrConnectWithoutTenantInput[]
    createMany?: MailboxAccountCreateManyTenantInputEnvelope
    connect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
  }

  export type RuleCreateNestedManyWithoutTenantInput = {
    create?: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput> | RuleCreateWithoutTenantInput[] | RuleUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: RuleCreateOrConnectWithoutTenantInput | RuleCreateOrConnectWithoutTenantInput[]
    createMany?: RuleCreateManyTenantInputEnvelope
    connect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
  }

  export type CleanupJobCreateNestedManyWithoutTenantInput = {
    create?: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput> | CleanupJobCreateWithoutTenantInput[] | CleanupJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutTenantInput | CleanupJobCreateOrConnectWithoutTenantInput[]
    createMany?: CleanupJobCreateManyTenantInputEnvelope
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
  }

  export type ExportJobUncheckedCreateNestedManyWithoutTenantInput = {
    create?: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput> | ExportJobCreateWithoutTenantInput[] | ExportJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: ExportJobCreateOrConnectWithoutTenantInput | ExportJobCreateOrConnectWithoutTenantInput[]
    createMany?: ExportJobCreateManyTenantInputEnvelope
    connect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutTenantInput = {
    create?: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput> | UserCreateWithoutTenantInput[] | UserUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: UserCreateOrConnectWithoutTenantInput | UserCreateOrConnectWithoutTenantInput[]
    createMany?: UserCreateManyTenantInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type MailboxAccountUncheckedCreateNestedManyWithoutTenantInput = {
    create?: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput> | MailboxAccountCreateWithoutTenantInput[] | MailboxAccountUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutTenantInput | MailboxAccountCreateOrConnectWithoutTenantInput[]
    createMany?: MailboxAccountCreateManyTenantInputEnvelope
    connect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
  }

  export type RuleUncheckedCreateNestedManyWithoutTenantInput = {
    create?: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput> | RuleCreateWithoutTenantInput[] | RuleUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: RuleCreateOrConnectWithoutTenantInput | RuleCreateOrConnectWithoutTenantInput[]
    createMany?: RuleCreateManyTenantInputEnvelope
    connect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
  }

  export type CleanupJobUncheckedCreateNestedManyWithoutTenantInput = {
    create?: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput> | CleanupJobCreateWithoutTenantInput[] | CleanupJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutTenantInput | CleanupJobCreateOrConnectWithoutTenantInput[]
    createMany?: CleanupJobCreateManyTenantInputEnvelope
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type ExportJobUpdateManyWithoutTenantNestedInput = {
    create?: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput> | ExportJobCreateWithoutTenantInput[] | ExportJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: ExportJobCreateOrConnectWithoutTenantInput | ExportJobCreateOrConnectWithoutTenantInput[]
    upsert?: ExportJobUpsertWithWhereUniqueWithoutTenantInput | ExportJobUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: ExportJobCreateManyTenantInputEnvelope
    set?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    disconnect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    delete?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    connect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    update?: ExportJobUpdateWithWhereUniqueWithoutTenantInput | ExportJobUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: ExportJobUpdateManyWithWhereWithoutTenantInput | ExportJobUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: ExportJobScalarWhereInput | ExportJobScalarWhereInput[]
  }

  export type UserUpdateManyWithoutTenantNestedInput = {
    create?: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput> | UserCreateWithoutTenantInput[] | UserUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: UserCreateOrConnectWithoutTenantInput | UserCreateOrConnectWithoutTenantInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutTenantInput | UserUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: UserCreateManyTenantInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutTenantInput | UserUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: UserUpdateManyWithWhereWithoutTenantInput | UserUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type MailboxAccountUpdateManyWithoutTenantNestedInput = {
    create?: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput> | MailboxAccountCreateWithoutTenantInput[] | MailboxAccountUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutTenantInput | MailboxAccountCreateOrConnectWithoutTenantInput[]
    upsert?: MailboxAccountUpsertWithWhereUniqueWithoutTenantInput | MailboxAccountUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: MailboxAccountCreateManyTenantInputEnvelope
    set?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    disconnect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    delete?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    connect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    update?: MailboxAccountUpdateWithWhereUniqueWithoutTenantInput | MailboxAccountUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: MailboxAccountUpdateManyWithWhereWithoutTenantInput | MailboxAccountUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: MailboxAccountScalarWhereInput | MailboxAccountScalarWhereInput[]
  }

  export type RuleUpdateManyWithoutTenantNestedInput = {
    create?: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput> | RuleCreateWithoutTenantInput[] | RuleUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: RuleCreateOrConnectWithoutTenantInput | RuleCreateOrConnectWithoutTenantInput[]
    upsert?: RuleUpsertWithWhereUniqueWithoutTenantInput | RuleUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: RuleCreateManyTenantInputEnvelope
    set?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    disconnect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    delete?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    connect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    update?: RuleUpdateWithWhereUniqueWithoutTenantInput | RuleUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: RuleUpdateManyWithWhereWithoutTenantInput | RuleUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: RuleScalarWhereInput | RuleScalarWhereInput[]
  }

  export type CleanupJobUpdateManyWithoutTenantNestedInput = {
    create?: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput> | CleanupJobCreateWithoutTenantInput[] | CleanupJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutTenantInput | CleanupJobCreateOrConnectWithoutTenantInput[]
    upsert?: CleanupJobUpsertWithWhereUniqueWithoutTenantInput | CleanupJobUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: CleanupJobCreateManyTenantInputEnvelope
    set?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    disconnect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    delete?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    update?: CleanupJobUpdateWithWhereUniqueWithoutTenantInput | CleanupJobUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: CleanupJobUpdateManyWithWhereWithoutTenantInput | CleanupJobUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
  }

  export type ExportJobUncheckedUpdateManyWithoutTenantNestedInput = {
    create?: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput> | ExportJobCreateWithoutTenantInput[] | ExportJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: ExportJobCreateOrConnectWithoutTenantInput | ExportJobCreateOrConnectWithoutTenantInput[]
    upsert?: ExportJobUpsertWithWhereUniqueWithoutTenantInput | ExportJobUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: ExportJobCreateManyTenantInputEnvelope
    set?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    disconnect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    delete?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    connect?: ExportJobWhereUniqueInput | ExportJobWhereUniqueInput[]
    update?: ExportJobUpdateWithWhereUniqueWithoutTenantInput | ExportJobUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: ExportJobUpdateManyWithWhereWithoutTenantInput | ExportJobUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: ExportJobScalarWhereInput | ExportJobScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutTenantNestedInput = {
    create?: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput> | UserCreateWithoutTenantInput[] | UserUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: UserCreateOrConnectWithoutTenantInput | UserCreateOrConnectWithoutTenantInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutTenantInput | UserUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: UserCreateManyTenantInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutTenantInput | UserUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: UserUpdateManyWithWhereWithoutTenantInput | UserUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput = {
    create?: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput> | MailboxAccountCreateWithoutTenantInput[] | MailboxAccountUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutTenantInput | MailboxAccountCreateOrConnectWithoutTenantInput[]
    upsert?: MailboxAccountUpsertWithWhereUniqueWithoutTenantInput | MailboxAccountUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: MailboxAccountCreateManyTenantInputEnvelope
    set?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    disconnect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    delete?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    connect?: MailboxAccountWhereUniqueInput | MailboxAccountWhereUniqueInput[]
    update?: MailboxAccountUpdateWithWhereUniqueWithoutTenantInput | MailboxAccountUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: MailboxAccountUpdateManyWithWhereWithoutTenantInput | MailboxAccountUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: MailboxAccountScalarWhereInput | MailboxAccountScalarWhereInput[]
  }

  export type RuleUncheckedUpdateManyWithoutTenantNestedInput = {
    create?: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput> | RuleCreateWithoutTenantInput[] | RuleUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: RuleCreateOrConnectWithoutTenantInput | RuleCreateOrConnectWithoutTenantInput[]
    upsert?: RuleUpsertWithWhereUniqueWithoutTenantInput | RuleUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: RuleCreateManyTenantInputEnvelope
    set?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    disconnect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    delete?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    connect?: RuleWhereUniqueInput | RuleWhereUniqueInput[]
    update?: RuleUpdateWithWhereUniqueWithoutTenantInput | RuleUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: RuleUpdateManyWithWhereWithoutTenantInput | RuleUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: RuleScalarWhereInput | RuleScalarWhereInput[]
  }

  export type CleanupJobUncheckedUpdateManyWithoutTenantNestedInput = {
    create?: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput> | CleanupJobCreateWithoutTenantInput[] | CleanupJobUncheckedCreateWithoutTenantInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutTenantInput | CleanupJobCreateOrConnectWithoutTenantInput[]
    upsert?: CleanupJobUpsertWithWhereUniqueWithoutTenantInput | CleanupJobUpsertWithWhereUniqueWithoutTenantInput[]
    createMany?: CleanupJobCreateManyTenantInputEnvelope
    set?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    disconnect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    delete?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    update?: CleanupJobUpdateWithWhereUniqueWithoutTenantInput | CleanupJobUpdateWithWhereUniqueWithoutTenantInput[]
    updateMany?: CleanupJobUpdateManyWithWhereWithoutTenantInput | CleanupJobUpdateManyWithWhereWithoutTenantInput[]
    deleteMany?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
  }

  export type TenantCreateNestedOneWithoutExportJobsInput = {
    create?: XOR<TenantCreateWithoutExportJobsInput, TenantUncheckedCreateWithoutExportJobsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutExportJobsInput
    connect?: TenantWhereUniqueInput
  }

  export type EnumExportStatusFieldUpdateOperationsInput = {
    set?: $Enums.ExportStatus
  }

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

  export type TenantUpdateOneRequiredWithoutExportJobsNestedInput = {
    create?: XOR<TenantCreateWithoutExportJobsInput, TenantUncheckedCreateWithoutExportJobsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutExportJobsInput
    upsert?: TenantUpsertWithoutExportJobsInput
    connect?: TenantWhereUniqueInput
    update?: XOR<XOR<TenantUpdateToOneWithWhereWithoutExportJobsInput, TenantUpdateWithoutExportJobsInput>, TenantUncheckedUpdateWithoutExportJobsInput>
  }

  export type TenantCreateNestedOneWithoutUsersInput = {
    create?: XOR<TenantCreateWithoutUsersInput, TenantUncheckedCreateWithoutUsersInput>
    connectOrCreate?: TenantCreateOrConnectWithoutUsersInput
    connect?: TenantWhereUniqueInput
  }

  export type EnumUserRoleFieldUpdateOperationsInput = {
    set?: $Enums.UserRole
  }

  export type TenantUpdateOneRequiredWithoutUsersNestedInput = {
    create?: XOR<TenantCreateWithoutUsersInput, TenantUncheckedCreateWithoutUsersInput>
    connectOrCreate?: TenantCreateOrConnectWithoutUsersInput
    upsert?: TenantUpsertWithoutUsersInput
    connect?: TenantWhereUniqueInput
    update?: XOR<XOR<TenantUpdateToOneWithWhereWithoutUsersInput, TenantUpdateWithoutUsersInput>, TenantUncheckedUpdateWithoutUsersInput>
  }

  export type TenantCreateNestedOneWithoutMailboxAccountsInput = {
    create?: XOR<TenantCreateWithoutMailboxAccountsInput, TenantUncheckedCreateWithoutMailboxAccountsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutMailboxAccountsInput
    connect?: TenantWhereUniqueInput
  }

  export type MailboxFolderCreateNestedManyWithoutMailboxAccountInput = {
    create?: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput> | MailboxFolderCreateWithoutMailboxAccountInput[] | MailboxFolderUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailboxAccountInput | MailboxFolderCreateOrConnectWithoutMailboxAccountInput[]
    createMany?: MailboxFolderCreateManyMailboxAccountInputEnvelope
    connect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
  }

  export type CleanupJobCreateNestedManyWithoutMailboxAccountInput = {
    create?: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput> | CleanupJobCreateWithoutMailboxAccountInput[] | CleanupJobUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutMailboxAccountInput | CleanupJobCreateOrConnectWithoutMailboxAccountInput[]
    createMany?: CleanupJobCreateManyMailboxAccountInputEnvelope
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
  }

  export type MailboxFolderUncheckedCreateNestedManyWithoutMailboxAccountInput = {
    create?: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput> | MailboxFolderCreateWithoutMailboxAccountInput[] | MailboxFolderUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailboxAccountInput | MailboxFolderCreateOrConnectWithoutMailboxAccountInput[]
    createMany?: MailboxFolderCreateManyMailboxAccountInputEnvelope
    connect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
  }

  export type CleanupJobUncheckedCreateNestedManyWithoutMailboxAccountInput = {
    create?: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput> | CleanupJobCreateWithoutMailboxAccountInput[] | CleanupJobUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutMailboxAccountInput | CleanupJobCreateOrConnectWithoutMailboxAccountInput[]
    createMany?: CleanupJobCreateManyMailboxAccountInputEnvelope
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
  }

  export type EnumMailProviderFieldUpdateOperationsInput = {
    set?: $Enums.MailProvider
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type TenantUpdateOneRequiredWithoutMailboxAccountsNestedInput = {
    create?: XOR<TenantCreateWithoutMailboxAccountsInput, TenantUncheckedCreateWithoutMailboxAccountsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutMailboxAccountsInput
    upsert?: TenantUpsertWithoutMailboxAccountsInput
    connect?: TenantWhereUniqueInput
    update?: XOR<XOR<TenantUpdateToOneWithWhereWithoutMailboxAccountsInput, TenantUpdateWithoutMailboxAccountsInput>, TenantUncheckedUpdateWithoutMailboxAccountsInput>
  }

  export type MailboxFolderUpdateManyWithoutMailboxAccountNestedInput = {
    create?: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput> | MailboxFolderCreateWithoutMailboxAccountInput[] | MailboxFolderUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailboxAccountInput | MailboxFolderCreateOrConnectWithoutMailboxAccountInput[]
    upsert?: MailboxFolderUpsertWithWhereUniqueWithoutMailboxAccountInput | MailboxFolderUpsertWithWhereUniqueWithoutMailboxAccountInput[]
    createMany?: MailboxFolderCreateManyMailboxAccountInputEnvelope
    set?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    disconnect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    delete?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    connect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    update?: MailboxFolderUpdateWithWhereUniqueWithoutMailboxAccountInput | MailboxFolderUpdateWithWhereUniqueWithoutMailboxAccountInput[]
    updateMany?: MailboxFolderUpdateManyWithWhereWithoutMailboxAccountInput | MailboxFolderUpdateManyWithWhereWithoutMailboxAccountInput[]
    deleteMany?: MailboxFolderScalarWhereInput | MailboxFolderScalarWhereInput[]
  }

  export type CleanupJobUpdateManyWithoutMailboxAccountNestedInput = {
    create?: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput> | CleanupJobCreateWithoutMailboxAccountInput[] | CleanupJobUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutMailboxAccountInput | CleanupJobCreateOrConnectWithoutMailboxAccountInput[]
    upsert?: CleanupJobUpsertWithWhereUniqueWithoutMailboxAccountInput | CleanupJobUpsertWithWhereUniqueWithoutMailboxAccountInput[]
    createMany?: CleanupJobCreateManyMailboxAccountInputEnvelope
    set?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    disconnect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    delete?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    update?: CleanupJobUpdateWithWhereUniqueWithoutMailboxAccountInput | CleanupJobUpdateWithWhereUniqueWithoutMailboxAccountInput[]
    updateMany?: CleanupJobUpdateManyWithWhereWithoutMailboxAccountInput | CleanupJobUpdateManyWithWhereWithoutMailboxAccountInput[]
    deleteMany?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
  }

  export type MailboxFolderUncheckedUpdateManyWithoutMailboxAccountNestedInput = {
    create?: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput> | MailboxFolderCreateWithoutMailboxAccountInput[] | MailboxFolderUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailboxAccountInput | MailboxFolderCreateOrConnectWithoutMailboxAccountInput[]
    upsert?: MailboxFolderUpsertWithWhereUniqueWithoutMailboxAccountInput | MailboxFolderUpsertWithWhereUniqueWithoutMailboxAccountInput[]
    createMany?: MailboxFolderCreateManyMailboxAccountInputEnvelope
    set?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    disconnect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    delete?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    connect?: MailboxFolderWhereUniqueInput | MailboxFolderWhereUniqueInput[]
    update?: MailboxFolderUpdateWithWhereUniqueWithoutMailboxAccountInput | MailboxFolderUpdateWithWhereUniqueWithoutMailboxAccountInput[]
    updateMany?: MailboxFolderUpdateManyWithWhereWithoutMailboxAccountInput | MailboxFolderUpdateManyWithWhereWithoutMailboxAccountInput[]
    deleteMany?: MailboxFolderScalarWhereInput | MailboxFolderScalarWhereInput[]
  }

  export type CleanupJobUncheckedUpdateManyWithoutMailboxAccountNestedInput = {
    create?: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput> | CleanupJobCreateWithoutMailboxAccountInput[] | CleanupJobUncheckedCreateWithoutMailboxAccountInput[]
    connectOrCreate?: CleanupJobCreateOrConnectWithoutMailboxAccountInput | CleanupJobCreateOrConnectWithoutMailboxAccountInput[]
    upsert?: CleanupJobUpsertWithWhereUniqueWithoutMailboxAccountInput | CleanupJobUpsertWithWhereUniqueWithoutMailboxAccountInput[]
    createMany?: CleanupJobCreateManyMailboxAccountInputEnvelope
    set?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    disconnect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    delete?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    connect?: CleanupJobWhereUniqueInput | CleanupJobWhereUniqueInput[]
    update?: CleanupJobUpdateWithWhereUniqueWithoutMailboxAccountInput | CleanupJobUpdateWithWhereUniqueWithoutMailboxAccountInput[]
    updateMany?: CleanupJobUpdateManyWithWhereWithoutMailboxAccountInput | CleanupJobUpdateManyWithWhereWithoutMailboxAccountInput[]
    deleteMany?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
  }

  export type MailboxAccountCreateNestedOneWithoutFoldersInput = {
    create?: XOR<MailboxAccountCreateWithoutFoldersInput, MailboxAccountUncheckedCreateWithoutFoldersInput>
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutFoldersInput
    connect?: MailboxAccountWhereUniqueInput
  }

  export type MailItemCreateNestedManyWithoutFolderInput = {
    create?: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput> | MailItemCreateWithoutFolderInput[] | MailItemUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: MailItemCreateOrConnectWithoutFolderInput | MailItemCreateOrConnectWithoutFolderInput[]
    createMany?: MailItemCreateManyFolderInputEnvelope
    connect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
  }

  export type MailItemUncheckedCreateNestedManyWithoutFolderInput = {
    create?: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput> | MailItemCreateWithoutFolderInput[] | MailItemUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: MailItemCreateOrConnectWithoutFolderInput | MailItemCreateOrConnectWithoutFolderInput[]
    createMany?: MailItemCreateManyFolderInputEnvelope
    connect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
  }

  export type MailboxAccountUpdateOneRequiredWithoutFoldersNestedInput = {
    create?: XOR<MailboxAccountCreateWithoutFoldersInput, MailboxAccountUncheckedCreateWithoutFoldersInput>
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutFoldersInput
    upsert?: MailboxAccountUpsertWithoutFoldersInput
    connect?: MailboxAccountWhereUniqueInput
    update?: XOR<XOR<MailboxAccountUpdateToOneWithWhereWithoutFoldersInput, MailboxAccountUpdateWithoutFoldersInput>, MailboxAccountUncheckedUpdateWithoutFoldersInput>
  }

  export type MailItemUpdateManyWithoutFolderNestedInput = {
    create?: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput> | MailItemCreateWithoutFolderInput[] | MailItemUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: MailItemCreateOrConnectWithoutFolderInput | MailItemCreateOrConnectWithoutFolderInput[]
    upsert?: MailItemUpsertWithWhereUniqueWithoutFolderInput | MailItemUpsertWithWhereUniqueWithoutFolderInput[]
    createMany?: MailItemCreateManyFolderInputEnvelope
    set?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    disconnect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    delete?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    connect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    update?: MailItemUpdateWithWhereUniqueWithoutFolderInput | MailItemUpdateWithWhereUniqueWithoutFolderInput[]
    updateMany?: MailItemUpdateManyWithWhereWithoutFolderInput | MailItemUpdateManyWithWhereWithoutFolderInput[]
    deleteMany?: MailItemScalarWhereInput | MailItemScalarWhereInput[]
  }

  export type MailItemUncheckedUpdateManyWithoutFolderNestedInput = {
    create?: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput> | MailItemCreateWithoutFolderInput[] | MailItemUncheckedCreateWithoutFolderInput[]
    connectOrCreate?: MailItemCreateOrConnectWithoutFolderInput | MailItemCreateOrConnectWithoutFolderInput[]
    upsert?: MailItemUpsertWithWhereUniqueWithoutFolderInput | MailItemUpsertWithWhereUniqueWithoutFolderInput[]
    createMany?: MailItemCreateManyFolderInputEnvelope
    set?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    disconnect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    delete?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    connect?: MailItemWhereUniqueInput | MailItemWhereUniqueInput[]
    update?: MailItemUpdateWithWhereUniqueWithoutFolderInput | MailItemUpdateWithWhereUniqueWithoutFolderInput[]
    updateMany?: MailItemUpdateManyWithWhereWithoutFolderInput | MailItemUpdateManyWithWhereWithoutFolderInput[]
    deleteMany?: MailItemScalarWhereInput | MailItemScalarWhereInput[]
  }

  export type MailboxFolderCreateNestedOneWithoutMailItemsInput = {
    create?: XOR<MailboxFolderCreateWithoutMailItemsInput, MailboxFolderUncheckedCreateWithoutMailItemsInput>
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailItemsInput
    connect?: MailboxFolderWhereUniqueInput
  }

  export type MailboxFolderUpdateOneRequiredWithoutMailItemsNestedInput = {
    create?: XOR<MailboxFolderCreateWithoutMailItemsInput, MailboxFolderUncheckedCreateWithoutMailItemsInput>
    connectOrCreate?: MailboxFolderCreateOrConnectWithoutMailItemsInput
    upsert?: MailboxFolderUpsertWithoutMailItemsInput
    connect?: MailboxFolderWhereUniqueInput
    update?: XOR<XOR<MailboxFolderUpdateToOneWithWhereWithoutMailItemsInput, MailboxFolderUpdateWithoutMailItemsInput>, MailboxFolderUncheckedUpdateWithoutMailItemsInput>
  }

  export type TenantCreateNestedOneWithoutRulesInput = {
    create?: XOR<TenantCreateWithoutRulesInput, TenantUncheckedCreateWithoutRulesInput>
    connectOrCreate?: TenantCreateOrConnectWithoutRulesInput
    connect?: TenantWhereUniqueInput
  }

  export type RuleConditionCreateNestedManyWithoutRuleInput = {
    create?: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput> | RuleConditionCreateWithoutRuleInput[] | RuleConditionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleConditionCreateOrConnectWithoutRuleInput | RuleConditionCreateOrConnectWithoutRuleInput[]
    createMany?: RuleConditionCreateManyRuleInputEnvelope
    connect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
  }

  export type RuleActionCreateNestedManyWithoutRuleInput = {
    create?: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput> | RuleActionCreateWithoutRuleInput[] | RuleActionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleActionCreateOrConnectWithoutRuleInput | RuleActionCreateOrConnectWithoutRuleInput[]
    createMany?: RuleActionCreateManyRuleInputEnvelope
    connect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
  }

  export type RuleConditionUncheckedCreateNestedManyWithoutRuleInput = {
    create?: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput> | RuleConditionCreateWithoutRuleInput[] | RuleConditionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleConditionCreateOrConnectWithoutRuleInput | RuleConditionCreateOrConnectWithoutRuleInput[]
    createMany?: RuleConditionCreateManyRuleInputEnvelope
    connect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
  }

  export type RuleActionUncheckedCreateNestedManyWithoutRuleInput = {
    create?: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput> | RuleActionCreateWithoutRuleInput[] | RuleActionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleActionCreateOrConnectWithoutRuleInput | RuleActionCreateOrConnectWithoutRuleInput[]
    createMany?: RuleActionCreateManyRuleInputEnvelope
    connect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
  }

  export type TenantUpdateOneRequiredWithoutRulesNestedInput = {
    create?: XOR<TenantCreateWithoutRulesInput, TenantUncheckedCreateWithoutRulesInput>
    connectOrCreate?: TenantCreateOrConnectWithoutRulesInput
    upsert?: TenantUpsertWithoutRulesInput
    connect?: TenantWhereUniqueInput
    update?: XOR<XOR<TenantUpdateToOneWithWhereWithoutRulesInput, TenantUpdateWithoutRulesInput>, TenantUncheckedUpdateWithoutRulesInput>
  }

  export type RuleConditionUpdateManyWithoutRuleNestedInput = {
    create?: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput> | RuleConditionCreateWithoutRuleInput[] | RuleConditionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleConditionCreateOrConnectWithoutRuleInput | RuleConditionCreateOrConnectWithoutRuleInput[]
    upsert?: RuleConditionUpsertWithWhereUniqueWithoutRuleInput | RuleConditionUpsertWithWhereUniqueWithoutRuleInput[]
    createMany?: RuleConditionCreateManyRuleInputEnvelope
    set?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    disconnect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    delete?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    connect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    update?: RuleConditionUpdateWithWhereUniqueWithoutRuleInput | RuleConditionUpdateWithWhereUniqueWithoutRuleInput[]
    updateMany?: RuleConditionUpdateManyWithWhereWithoutRuleInput | RuleConditionUpdateManyWithWhereWithoutRuleInput[]
    deleteMany?: RuleConditionScalarWhereInput | RuleConditionScalarWhereInput[]
  }

  export type RuleActionUpdateManyWithoutRuleNestedInput = {
    create?: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput> | RuleActionCreateWithoutRuleInput[] | RuleActionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleActionCreateOrConnectWithoutRuleInput | RuleActionCreateOrConnectWithoutRuleInput[]
    upsert?: RuleActionUpsertWithWhereUniqueWithoutRuleInput | RuleActionUpsertWithWhereUniqueWithoutRuleInput[]
    createMany?: RuleActionCreateManyRuleInputEnvelope
    set?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    disconnect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    delete?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    connect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    update?: RuleActionUpdateWithWhereUniqueWithoutRuleInput | RuleActionUpdateWithWhereUniqueWithoutRuleInput[]
    updateMany?: RuleActionUpdateManyWithWhereWithoutRuleInput | RuleActionUpdateManyWithWhereWithoutRuleInput[]
    deleteMany?: RuleActionScalarWhereInput | RuleActionScalarWhereInput[]
  }

  export type RuleConditionUncheckedUpdateManyWithoutRuleNestedInput = {
    create?: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput> | RuleConditionCreateWithoutRuleInput[] | RuleConditionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleConditionCreateOrConnectWithoutRuleInput | RuleConditionCreateOrConnectWithoutRuleInput[]
    upsert?: RuleConditionUpsertWithWhereUniqueWithoutRuleInput | RuleConditionUpsertWithWhereUniqueWithoutRuleInput[]
    createMany?: RuleConditionCreateManyRuleInputEnvelope
    set?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    disconnect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    delete?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    connect?: RuleConditionWhereUniqueInput | RuleConditionWhereUniqueInput[]
    update?: RuleConditionUpdateWithWhereUniqueWithoutRuleInput | RuleConditionUpdateWithWhereUniqueWithoutRuleInput[]
    updateMany?: RuleConditionUpdateManyWithWhereWithoutRuleInput | RuleConditionUpdateManyWithWhereWithoutRuleInput[]
    deleteMany?: RuleConditionScalarWhereInput | RuleConditionScalarWhereInput[]
  }

  export type RuleActionUncheckedUpdateManyWithoutRuleNestedInput = {
    create?: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput> | RuleActionCreateWithoutRuleInput[] | RuleActionUncheckedCreateWithoutRuleInput[]
    connectOrCreate?: RuleActionCreateOrConnectWithoutRuleInput | RuleActionCreateOrConnectWithoutRuleInput[]
    upsert?: RuleActionUpsertWithWhereUniqueWithoutRuleInput | RuleActionUpsertWithWhereUniqueWithoutRuleInput[]
    createMany?: RuleActionCreateManyRuleInputEnvelope
    set?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    disconnect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    delete?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    connect?: RuleActionWhereUniqueInput | RuleActionWhereUniqueInput[]
    update?: RuleActionUpdateWithWhereUniqueWithoutRuleInput | RuleActionUpdateWithWhereUniqueWithoutRuleInput[]
    updateMany?: RuleActionUpdateManyWithWhereWithoutRuleInput | RuleActionUpdateManyWithWhereWithoutRuleInput[]
    deleteMany?: RuleActionScalarWhereInput | RuleActionScalarWhereInput[]
  }

  export type RuleCreateNestedOneWithoutConditionsInput = {
    create?: XOR<RuleCreateWithoutConditionsInput, RuleUncheckedCreateWithoutConditionsInput>
    connectOrCreate?: RuleCreateOrConnectWithoutConditionsInput
    connect?: RuleWhereUniqueInput
  }

  export type EnumRuleConditionTypeFieldUpdateOperationsInput = {
    set?: $Enums.RuleConditionType
  }

  export type RuleUpdateOneRequiredWithoutConditionsNestedInput = {
    create?: XOR<RuleCreateWithoutConditionsInput, RuleUncheckedCreateWithoutConditionsInput>
    connectOrCreate?: RuleCreateOrConnectWithoutConditionsInput
    upsert?: RuleUpsertWithoutConditionsInput
    connect?: RuleWhereUniqueInput
    update?: XOR<XOR<RuleUpdateToOneWithWhereWithoutConditionsInput, RuleUpdateWithoutConditionsInput>, RuleUncheckedUpdateWithoutConditionsInput>
  }

  export type RuleCreateNestedOneWithoutActionsInput = {
    create?: XOR<RuleCreateWithoutActionsInput, RuleUncheckedCreateWithoutActionsInput>
    connectOrCreate?: RuleCreateOrConnectWithoutActionsInput
    connect?: RuleWhereUniqueInput
  }

  export type EnumRuleActionTypeFieldUpdateOperationsInput = {
    set?: $Enums.RuleActionType
  }

  export type RuleUpdateOneRequiredWithoutActionsNestedInput = {
    create?: XOR<RuleCreateWithoutActionsInput, RuleUncheckedCreateWithoutActionsInput>
    connectOrCreate?: RuleCreateOrConnectWithoutActionsInput
    upsert?: RuleUpsertWithoutActionsInput
    connect?: RuleWhereUniqueInput
    update?: XOR<XOR<RuleUpdateToOneWithWhereWithoutActionsInput, RuleUpdateWithoutActionsInput>, RuleUncheckedUpdateWithoutActionsInput>
  }

  export type TenantCreateNestedOneWithoutJobsInput = {
    create?: XOR<TenantCreateWithoutJobsInput, TenantUncheckedCreateWithoutJobsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutJobsInput
    connect?: TenantWhereUniqueInput
  }

  export type MailboxAccountCreateNestedOneWithoutJobsInput = {
    create?: XOR<MailboxAccountCreateWithoutJobsInput, MailboxAccountUncheckedCreateWithoutJobsInput>
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutJobsInput
    connect?: MailboxAccountWhereUniqueInput
  }

  export type UnsubscribeAttemptCreateNestedManyWithoutJobInput = {
    create?: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput> | UnsubscribeAttemptCreateWithoutJobInput[] | UnsubscribeAttemptUncheckedCreateWithoutJobInput[]
    connectOrCreate?: UnsubscribeAttemptCreateOrConnectWithoutJobInput | UnsubscribeAttemptCreateOrConnectWithoutJobInput[]
    createMany?: UnsubscribeAttemptCreateManyJobInputEnvelope
    connect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
  }

  export type CleanupJobEventCreateNestedManyWithoutJobInput = {
    create?: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput> | CleanupJobEventCreateWithoutJobInput[] | CleanupJobEventUncheckedCreateWithoutJobInput[]
    connectOrCreate?: CleanupJobEventCreateOrConnectWithoutJobInput | CleanupJobEventCreateOrConnectWithoutJobInput[]
    createMany?: CleanupJobEventCreateManyJobInputEnvelope
    connect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
  }

  export type UnsubscribeAttemptUncheckedCreateNestedManyWithoutJobInput = {
    create?: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput> | UnsubscribeAttemptCreateWithoutJobInput[] | UnsubscribeAttemptUncheckedCreateWithoutJobInput[]
    connectOrCreate?: UnsubscribeAttemptCreateOrConnectWithoutJobInput | UnsubscribeAttemptCreateOrConnectWithoutJobInput[]
    createMany?: UnsubscribeAttemptCreateManyJobInputEnvelope
    connect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
  }

  export type CleanupJobEventUncheckedCreateNestedManyWithoutJobInput = {
    create?: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput> | CleanupJobEventCreateWithoutJobInput[] | CleanupJobEventUncheckedCreateWithoutJobInput[]
    connectOrCreate?: CleanupJobEventCreateOrConnectWithoutJobInput | CleanupJobEventCreateOrConnectWithoutJobInput[]
    createMany?: CleanupJobEventCreateManyJobInputEnvelope
    connect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
  }

  export type EnumJobStatusFieldUpdateOperationsInput = {
    set?: $Enums.JobStatus
  }

  export type TenantUpdateOneRequiredWithoutJobsNestedInput = {
    create?: XOR<TenantCreateWithoutJobsInput, TenantUncheckedCreateWithoutJobsInput>
    connectOrCreate?: TenantCreateOrConnectWithoutJobsInput
    upsert?: TenantUpsertWithoutJobsInput
    connect?: TenantWhereUniqueInput
    update?: XOR<XOR<TenantUpdateToOneWithWhereWithoutJobsInput, TenantUpdateWithoutJobsInput>, TenantUncheckedUpdateWithoutJobsInput>
  }

  export type MailboxAccountUpdateOneRequiredWithoutJobsNestedInput = {
    create?: XOR<MailboxAccountCreateWithoutJobsInput, MailboxAccountUncheckedCreateWithoutJobsInput>
    connectOrCreate?: MailboxAccountCreateOrConnectWithoutJobsInput
    upsert?: MailboxAccountUpsertWithoutJobsInput
    connect?: MailboxAccountWhereUniqueInput
    update?: XOR<XOR<MailboxAccountUpdateToOneWithWhereWithoutJobsInput, MailboxAccountUpdateWithoutJobsInput>, MailboxAccountUncheckedUpdateWithoutJobsInput>
  }

  export type UnsubscribeAttemptUpdateManyWithoutJobNestedInput = {
    create?: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput> | UnsubscribeAttemptCreateWithoutJobInput[] | UnsubscribeAttemptUncheckedCreateWithoutJobInput[]
    connectOrCreate?: UnsubscribeAttemptCreateOrConnectWithoutJobInput | UnsubscribeAttemptCreateOrConnectWithoutJobInput[]
    upsert?: UnsubscribeAttemptUpsertWithWhereUniqueWithoutJobInput | UnsubscribeAttemptUpsertWithWhereUniqueWithoutJobInput[]
    createMany?: UnsubscribeAttemptCreateManyJobInputEnvelope
    set?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    disconnect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    delete?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    connect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    update?: UnsubscribeAttemptUpdateWithWhereUniqueWithoutJobInput | UnsubscribeAttemptUpdateWithWhereUniqueWithoutJobInput[]
    updateMany?: UnsubscribeAttemptUpdateManyWithWhereWithoutJobInput | UnsubscribeAttemptUpdateManyWithWhereWithoutJobInput[]
    deleteMany?: UnsubscribeAttemptScalarWhereInput | UnsubscribeAttemptScalarWhereInput[]
  }

  export type CleanupJobEventUpdateManyWithoutJobNestedInput = {
    create?: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput> | CleanupJobEventCreateWithoutJobInput[] | CleanupJobEventUncheckedCreateWithoutJobInput[]
    connectOrCreate?: CleanupJobEventCreateOrConnectWithoutJobInput | CleanupJobEventCreateOrConnectWithoutJobInput[]
    upsert?: CleanupJobEventUpsertWithWhereUniqueWithoutJobInput | CleanupJobEventUpsertWithWhereUniqueWithoutJobInput[]
    createMany?: CleanupJobEventCreateManyJobInputEnvelope
    set?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    disconnect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    delete?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    connect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    update?: CleanupJobEventUpdateWithWhereUniqueWithoutJobInput | CleanupJobEventUpdateWithWhereUniqueWithoutJobInput[]
    updateMany?: CleanupJobEventUpdateManyWithWhereWithoutJobInput | CleanupJobEventUpdateManyWithWhereWithoutJobInput[]
    deleteMany?: CleanupJobEventScalarWhereInput | CleanupJobEventScalarWhereInput[]
  }

  export type UnsubscribeAttemptUncheckedUpdateManyWithoutJobNestedInput = {
    create?: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput> | UnsubscribeAttemptCreateWithoutJobInput[] | UnsubscribeAttemptUncheckedCreateWithoutJobInput[]
    connectOrCreate?: UnsubscribeAttemptCreateOrConnectWithoutJobInput | UnsubscribeAttemptCreateOrConnectWithoutJobInput[]
    upsert?: UnsubscribeAttemptUpsertWithWhereUniqueWithoutJobInput | UnsubscribeAttemptUpsertWithWhereUniqueWithoutJobInput[]
    createMany?: UnsubscribeAttemptCreateManyJobInputEnvelope
    set?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    disconnect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    delete?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    connect?: UnsubscribeAttemptWhereUniqueInput | UnsubscribeAttemptWhereUniqueInput[]
    update?: UnsubscribeAttemptUpdateWithWhereUniqueWithoutJobInput | UnsubscribeAttemptUpdateWithWhereUniqueWithoutJobInput[]
    updateMany?: UnsubscribeAttemptUpdateManyWithWhereWithoutJobInput | UnsubscribeAttemptUpdateManyWithWhereWithoutJobInput[]
    deleteMany?: UnsubscribeAttemptScalarWhereInput | UnsubscribeAttemptScalarWhereInput[]
  }

  export type CleanupJobEventUncheckedUpdateManyWithoutJobNestedInput = {
    create?: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput> | CleanupJobEventCreateWithoutJobInput[] | CleanupJobEventUncheckedCreateWithoutJobInput[]
    connectOrCreate?: CleanupJobEventCreateOrConnectWithoutJobInput | CleanupJobEventCreateOrConnectWithoutJobInput[]
    upsert?: CleanupJobEventUpsertWithWhereUniqueWithoutJobInput | CleanupJobEventUpsertWithWhereUniqueWithoutJobInput[]
    createMany?: CleanupJobEventCreateManyJobInputEnvelope
    set?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    disconnect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    delete?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    connect?: CleanupJobEventWhereUniqueInput | CleanupJobEventWhereUniqueInput[]
    update?: CleanupJobEventUpdateWithWhereUniqueWithoutJobInput | CleanupJobEventUpdateWithWhereUniqueWithoutJobInput[]
    updateMany?: CleanupJobEventUpdateManyWithWhereWithoutJobInput | CleanupJobEventUpdateManyWithWhereWithoutJobInput[]
    deleteMany?: CleanupJobEventScalarWhereInput | CleanupJobEventScalarWhereInput[]
  }

  export type CleanupJobCreateNestedOneWithoutUnsubscribeAttemptsInput = {
    create?: XOR<CleanupJobCreateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedCreateWithoutUnsubscribeAttemptsInput>
    connectOrCreate?: CleanupJobCreateOrConnectWithoutUnsubscribeAttemptsInput
    connect?: CleanupJobWhereUniqueInput
  }

  export type CleanupJobUpdateOneRequiredWithoutUnsubscribeAttemptsNestedInput = {
    create?: XOR<CleanupJobCreateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedCreateWithoutUnsubscribeAttemptsInput>
    connectOrCreate?: CleanupJobCreateOrConnectWithoutUnsubscribeAttemptsInput
    upsert?: CleanupJobUpsertWithoutUnsubscribeAttemptsInput
    connect?: CleanupJobWhereUniqueInput
    update?: XOR<XOR<CleanupJobUpdateToOneWithWhereWithoutUnsubscribeAttemptsInput, CleanupJobUpdateWithoutUnsubscribeAttemptsInput>, CleanupJobUncheckedUpdateWithoutUnsubscribeAttemptsInput>
  }

  export type CleanupJobCreateNestedOneWithoutEventsInput = {
    create?: XOR<CleanupJobCreateWithoutEventsInput, CleanupJobUncheckedCreateWithoutEventsInput>
    connectOrCreate?: CleanupJobCreateOrConnectWithoutEventsInput
    connect?: CleanupJobWhereUniqueInput
  }

  export type CleanupJobUpdateOneRequiredWithoutEventsNestedInput = {
    create?: XOR<CleanupJobCreateWithoutEventsInput, CleanupJobUncheckedCreateWithoutEventsInput>
    connectOrCreate?: CleanupJobCreateOrConnectWithoutEventsInput
    upsert?: CleanupJobUpsertWithoutEventsInput
    connect?: CleanupJobWhereUniqueInput
    update?: XOR<XOR<CleanupJobUpdateToOneWithWhereWithoutEventsInput, CleanupJobUpdateWithoutEventsInput>, CleanupJobUncheckedUpdateWithoutEventsInput>
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type 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 NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$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 NestedEnumExportStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.ExportStatus | EnumExportStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumExportStatusFilter<$PrismaModel> | $Enums.ExportStatus
  }

  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 NestedEnumExportStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ExportStatus | EnumExportStatusFieldRefInput<$PrismaModel>
    in?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.ExportStatus[] | ListEnumExportStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumExportStatusWithAggregatesFilter<$PrismaModel> | $Enums.ExportStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumExportStatusFilter<$PrismaModel>
    _max?: NestedEnumExportStatusFilter<$PrismaModel>
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type 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 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 NestedEnumMailProviderFilter<$PrismaModel = never> = {
    equals?: $Enums.MailProvider | EnumMailProviderFieldRefInput<$PrismaModel>
    in?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumMailProviderFilter<$PrismaModel> | $Enums.MailProvider
  }

  export type NestedBoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  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 NestedEnumMailProviderWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MailProvider | EnumMailProviderFieldRefInput<$PrismaModel>
    in?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.MailProvider[] | ListEnumMailProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumMailProviderWithAggregatesFilter<$PrismaModel> | $Enums.MailProvider
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMailProviderFilter<$PrismaModel>
    _max?: NestedEnumMailProviderFilter<$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 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 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 NestedBoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedEnumRuleConditionTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleConditionType | EnumRuleConditionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleConditionTypeFilter<$PrismaModel> | $Enums.RuleConditionType
  }

  export type NestedEnumRuleConditionTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleConditionType | EnumRuleConditionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleConditionType[] | ListEnumRuleConditionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleConditionTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleConditionType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleConditionTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleConditionTypeFilter<$PrismaModel>
  }

  export type NestedEnumRuleActionTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleActionType | EnumRuleActionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionTypeFilter<$PrismaModel> | $Enums.RuleActionType
  }

  export type NestedEnumRuleActionTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RuleActionType | EnumRuleActionTypeFieldRefInput<$PrismaModel>
    in?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.RuleActionType[] | ListEnumRuleActionTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumRuleActionTypeWithAggregatesFilter<$PrismaModel> | $Enums.RuleActionType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRuleActionTypeFilter<$PrismaModel>
    _max?: NestedEnumRuleActionTypeFilter<$PrismaModel>
  }

  export type NestedEnumJobStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.JobStatus | EnumJobStatusFieldRefInput<$PrismaModel>
    in?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumJobStatusFilter<$PrismaModel> | $Enums.JobStatus
  }

  export type NestedEnumJobStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.JobStatus | EnumJobStatusFieldRefInput<$PrismaModel>
    in?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.JobStatus[] | ListEnumJobStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumJobStatusWithAggregatesFilter<$PrismaModel> | $Enums.JobStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumJobStatusFilter<$PrismaModel>
    _max?: NestedEnumJobStatusFilter<$PrismaModel>
  }

  export type ExportJobCreateWithoutTenantInput = {
    id?: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExportJobUncheckedCreateWithoutTenantInput = {
    id?: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExportJobCreateOrConnectWithoutTenantInput = {
    where: ExportJobWhereUniqueInput
    create: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput>
  }

  export type ExportJobCreateManyTenantInputEnvelope = {
    data: ExportJobCreateManyTenantInput | ExportJobCreateManyTenantInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutTenantInput = {
    id?: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserUncheckedCreateWithoutTenantInput = {
    id?: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserCreateOrConnectWithoutTenantInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput>
  }

  export type UserCreateManyTenantInputEnvelope = {
    data: UserCreateManyTenantInput | UserCreateManyTenantInput[]
    skipDuplicates?: boolean
  }

  export type MailboxAccountCreateWithoutTenantInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folders?: MailboxFolderCreateNestedManyWithoutMailboxAccountInput
    jobs?: CleanupJobCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountUncheckedCreateWithoutTenantInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folders?: MailboxFolderUncheckedCreateNestedManyWithoutMailboxAccountInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountCreateOrConnectWithoutTenantInput = {
    where: MailboxAccountWhereUniqueInput
    create: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput>
  }

  export type MailboxAccountCreateManyTenantInputEnvelope = {
    data: MailboxAccountCreateManyTenantInput | MailboxAccountCreateManyTenantInput[]
    skipDuplicates?: boolean
  }

  export type RuleCreateWithoutTenantInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    conditions?: RuleConditionCreateNestedManyWithoutRuleInput
    actions?: RuleActionCreateNestedManyWithoutRuleInput
  }

  export type RuleUncheckedCreateWithoutTenantInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    conditions?: RuleConditionUncheckedCreateNestedManyWithoutRuleInput
    actions?: RuleActionUncheckedCreateNestedManyWithoutRuleInput
  }

  export type RuleCreateOrConnectWithoutTenantInput = {
    where: RuleWhereUniqueInput
    create: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput>
  }

  export type RuleCreateManyTenantInputEnvelope = {
    data: RuleCreateManyTenantInput | RuleCreateManyTenantInput[]
    skipDuplicates?: boolean
  }

  export type CleanupJobCreateWithoutTenantInput = {
    id?: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailboxAccount: MailboxAccountCreateNestedOneWithoutJobsInput
    unsubscribeAttempts?: UnsubscribeAttemptCreateNestedManyWithoutJobInput
    events?: CleanupJobEventCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUncheckedCreateWithoutTenantInput = {
    id?: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedCreateNestedManyWithoutJobInput
    events?: CleanupJobEventUncheckedCreateNestedManyWithoutJobInput
  }

  export type CleanupJobCreateOrConnectWithoutTenantInput = {
    where: CleanupJobWhereUniqueInput
    create: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput>
  }

  export type CleanupJobCreateManyTenantInputEnvelope = {
    data: CleanupJobCreateManyTenantInput | CleanupJobCreateManyTenantInput[]
    skipDuplicates?: boolean
  }

  export type ExportJobUpsertWithWhereUniqueWithoutTenantInput = {
    where: ExportJobWhereUniqueInput
    update: XOR<ExportJobUpdateWithoutTenantInput, ExportJobUncheckedUpdateWithoutTenantInput>
    create: XOR<ExportJobCreateWithoutTenantInput, ExportJobUncheckedCreateWithoutTenantInput>
  }

  export type ExportJobUpdateWithWhereUniqueWithoutTenantInput = {
    where: ExportJobWhereUniqueInput
    data: XOR<ExportJobUpdateWithoutTenantInput, ExportJobUncheckedUpdateWithoutTenantInput>
  }

  export type ExportJobUpdateManyWithWhereWithoutTenantInput = {
    where: ExportJobScalarWhereInput
    data: XOR<ExportJobUpdateManyMutationInput, ExportJobUncheckedUpdateManyWithoutTenantInput>
  }

  export type ExportJobScalarWhereInput = {
    AND?: ExportJobScalarWhereInput | ExportJobScalarWhereInput[]
    OR?: ExportJobScalarWhereInput[]
    NOT?: ExportJobScalarWhereInput | ExportJobScalarWhereInput[]
    id?: StringFilter<"ExportJob"> | string
    tenantId?: StringFilter<"ExportJob"> | string
    status?: EnumExportStatusFilter<"ExportJob"> | $Enums.ExportStatus
    format?: StringFilter<"ExportJob"> | string
    scope?: StringFilter<"ExportJob"> | string
    filePath?: StringNullableFilter<"ExportJob"> | string | null
    error?: StringNullableFilter<"ExportJob"> | string | null
    createdAt?: DateTimeFilter<"ExportJob"> | Date | string
    updatedAt?: DateTimeFilter<"ExportJob"> | Date | string
  }

  export type UserUpsertWithWhereUniqueWithoutTenantInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutTenantInput, UserUncheckedUpdateWithoutTenantInput>
    create: XOR<UserCreateWithoutTenantInput, UserUncheckedCreateWithoutTenantInput>
  }

  export type UserUpdateWithWhereUniqueWithoutTenantInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutTenantInput, UserUncheckedUpdateWithoutTenantInput>
  }

  export type UserUpdateManyWithWhereWithoutTenantInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutTenantInput>
  }

  export type UserScalarWhereInput = {
    AND?: UserScalarWhereInput | UserScalarWhereInput[]
    OR?: UserScalarWhereInput[]
    NOT?: UserScalarWhereInput | UserScalarWhereInput[]
    id?: StringFilter<"User"> | string
    tenantId?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    isActive?: BoolFilter<"User"> | boolean
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
  }

  export type MailboxAccountUpsertWithWhereUniqueWithoutTenantInput = {
    where: MailboxAccountWhereUniqueInput
    update: XOR<MailboxAccountUpdateWithoutTenantInput, MailboxAccountUncheckedUpdateWithoutTenantInput>
    create: XOR<MailboxAccountCreateWithoutTenantInput, MailboxAccountUncheckedCreateWithoutTenantInput>
  }

  export type MailboxAccountUpdateWithWhereUniqueWithoutTenantInput = {
    where: MailboxAccountWhereUniqueInput
    data: XOR<MailboxAccountUpdateWithoutTenantInput, MailboxAccountUncheckedUpdateWithoutTenantInput>
  }

  export type MailboxAccountUpdateManyWithWhereWithoutTenantInput = {
    where: MailboxAccountScalarWhereInput
    data: XOR<MailboxAccountUpdateManyMutationInput, MailboxAccountUncheckedUpdateManyWithoutTenantInput>
  }

  export type MailboxAccountScalarWhereInput = {
    AND?: MailboxAccountScalarWhereInput | MailboxAccountScalarWhereInput[]
    OR?: MailboxAccountScalarWhereInput[]
    NOT?: MailboxAccountScalarWhereInput | MailboxAccountScalarWhereInput[]
    id?: StringFilter<"MailboxAccount"> | string
    tenantId?: StringFilter<"MailboxAccount"> | string
    email?: StringFilter<"MailboxAccount"> | string
    provider?: EnumMailProviderFilter<"MailboxAccount"> | $Enums.MailProvider
    isActive?: BoolFilter<"MailboxAccount"> | boolean
    imapHost?: StringFilter<"MailboxAccount"> | string
    imapPort?: IntFilter<"MailboxAccount"> | number
    imapTLS?: BoolFilter<"MailboxAccount"> | boolean
    smtpHost?: StringNullableFilter<"MailboxAccount"> | string | null
    smtpPort?: IntNullableFilter<"MailboxAccount"> | number | null
    smtpTLS?: BoolNullableFilter<"MailboxAccount"> | boolean | null
    oauthToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthRefreshToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthAccessToken?: StringNullableFilter<"MailboxAccount"> | string | null
    oauthExpiresAt?: DateTimeNullableFilter<"MailboxAccount"> | Date | string | null
    providerUserId?: StringNullableFilter<"MailboxAccount"> | string | null
    appPassword?: StringNullableFilter<"MailboxAccount"> | string | null
    createdAt?: DateTimeFilter<"MailboxAccount"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxAccount"> | Date | string
  }

  export type RuleUpsertWithWhereUniqueWithoutTenantInput = {
    where: RuleWhereUniqueInput
    update: XOR<RuleUpdateWithoutTenantInput, RuleUncheckedUpdateWithoutTenantInput>
    create: XOR<RuleCreateWithoutTenantInput, RuleUncheckedCreateWithoutTenantInput>
  }

  export type RuleUpdateWithWhereUniqueWithoutTenantInput = {
    where: RuleWhereUniqueInput
    data: XOR<RuleUpdateWithoutTenantInput, RuleUncheckedUpdateWithoutTenantInput>
  }

  export type RuleUpdateManyWithWhereWithoutTenantInput = {
    where: RuleScalarWhereInput
    data: XOR<RuleUpdateManyMutationInput, RuleUncheckedUpdateManyWithoutTenantInput>
  }

  export type RuleScalarWhereInput = {
    AND?: RuleScalarWhereInput | RuleScalarWhereInput[]
    OR?: RuleScalarWhereInput[]
    NOT?: RuleScalarWhereInput | RuleScalarWhereInput[]
    id?: StringFilter<"Rule"> | string
    tenantId?: StringFilter<"Rule"> | string
    name?: StringFilter<"Rule"> | string
    enabled?: BoolFilter<"Rule"> | boolean
    createdAt?: DateTimeFilter<"Rule"> | Date | string
    updatedAt?: DateTimeFilter<"Rule"> | Date | string
  }

  export type CleanupJobUpsertWithWhereUniqueWithoutTenantInput = {
    where: CleanupJobWhereUniqueInput
    update: XOR<CleanupJobUpdateWithoutTenantInput, CleanupJobUncheckedUpdateWithoutTenantInput>
    create: XOR<CleanupJobCreateWithoutTenantInput, CleanupJobUncheckedCreateWithoutTenantInput>
  }

  export type CleanupJobUpdateWithWhereUniqueWithoutTenantInput = {
    where: CleanupJobWhereUniqueInput
    data: XOR<CleanupJobUpdateWithoutTenantInput, CleanupJobUncheckedUpdateWithoutTenantInput>
  }

  export type CleanupJobUpdateManyWithWhereWithoutTenantInput = {
    where: CleanupJobScalarWhereInput
    data: XOR<CleanupJobUpdateManyMutationInput, CleanupJobUncheckedUpdateManyWithoutTenantInput>
  }

  export type CleanupJobScalarWhereInput = {
    AND?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
    OR?: CleanupJobScalarWhereInput[]
    NOT?: CleanupJobScalarWhereInput | CleanupJobScalarWhereInput[]
    id?: StringFilter<"CleanupJob"> | string
    tenantId?: StringFilter<"CleanupJob"> | string
    mailboxAccountId?: StringFilter<"CleanupJob"> | string
    status?: EnumJobStatusFilter<"CleanupJob"> | $Enums.JobStatus
    dryRun?: BoolFilter<"CleanupJob"> | boolean
    unsubscribeEnabled?: BoolFilter<"CleanupJob"> | boolean
    routingEnabled?: BoolFilter<"CleanupJob"> | boolean
    startedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    finishedAt?: DateTimeNullableFilter<"CleanupJob"> | Date | string | null
    createdAt?: DateTimeFilter<"CleanupJob"> | Date | string
    updatedAt?: DateTimeFilter<"CleanupJob"> | Date | string
  }

  export type TenantCreateWithoutExportJobsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    users?: UserCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountCreateNestedManyWithoutTenantInput
    rules?: RuleCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateWithoutExportJobsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountUncheckedCreateNestedManyWithoutTenantInput
    rules?: RuleUncheckedCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantCreateOrConnectWithoutExportJobsInput = {
    where: TenantWhereUniqueInput
    create: XOR<TenantCreateWithoutExportJobsInput, TenantUncheckedCreateWithoutExportJobsInput>
  }

  export type TenantUpsertWithoutExportJobsInput = {
    update: XOR<TenantUpdateWithoutExportJobsInput, TenantUncheckedUpdateWithoutExportJobsInput>
    create: XOR<TenantCreateWithoutExportJobsInput, TenantUncheckedCreateWithoutExportJobsInput>
    where?: TenantWhereInput
  }

  export type TenantUpdateToOneWithWhereWithoutExportJobsInput = {
    where?: TenantWhereInput
    data: XOR<TenantUpdateWithoutExportJobsInput, TenantUncheckedUpdateWithoutExportJobsInput>
  }

  export type TenantUpdateWithoutExportJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUpdateManyWithoutTenantNestedInput
    rules?: RuleUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateWithoutExportJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput
    rules?: RuleUncheckedUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type TenantCreateWithoutUsersInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountCreateNestedManyWithoutTenantInput
    rules?: RuleCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobUncheckedCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountUncheckedCreateNestedManyWithoutTenantInput
    rules?: RuleUncheckedCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantCreateOrConnectWithoutUsersInput = {
    where: TenantWhereUniqueInput
    create: XOR<TenantCreateWithoutUsersInput, TenantUncheckedCreateWithoutUsersInput>
  }

  export type TenantUpsertWithoutUsersInput = {
    update: XOR<TenantUpdateWithoutUsersInput, TenantUncheckedUpdateWithoutUsersInput>
    create: XOR<TenantCreateWithoutUsersInput, TenantUncheckedCreateWithoutUsersInput>
    where?: TenantWhereInput
  }

  export type TenantUpdateToOneWithWhereWithoutUsersInput = {
    where?: TenantWhereInput
    data: XOR<TenantUpdateWithoutUsersInput, TenantUncheckedUpdateWithoutUsersInput>
  }

  export type TenantUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUpdateManyWithoutTenantNestedInput
    rules?: RuleUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUncheckedUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput
    rules?: RuleUncheckedUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type TenantCreateWithoutMailboxAccountsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobCreateNestedManyWithoutTenantInput
    users?: UserCreateNestedManyWithoutTenantInput
    rules?: RuleCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateWithoutMailboxAccountsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobUncheckedCreateNestedManyWithoutTenantInput
    users?: UserUncheckedCreateNestedManyWithoutTenantInput
    rules?: RuleUncheckedCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantCreateOrConnectWithoutMailboxAccountsInput = {
    where: TenantWhereUniqueInput
    create: XOR<TenantCreateWithoutMailboxAccountsInput, TenantUncheckedCreateWithoutMailboxAccountsInput>
  }

  export type MailboxFolderCreateWithoutMailboxAccountInput = {
    id?: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailItems?: MailItemCreateNestedManyWithoutFolderInput
  }

  export type MailboxFolderUncheckedCreateWithoutMailboxAccountInput = {
    id?: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailItems?: MailItemUncheckedCreateNestedManyWithoutFolderInput
  }

  export type MailboxFolderCreateOrConnectWithoutMailboxAccountInput = {
    where: MailboxFolderWhereUniqueInput
    create: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput>
  }

  export type MailboxFolderCreateManyMailboxAccountInputEnvelope = {
    data: MailboxFolderCreateManyMailboxAccountInput | MailboxFolderCreateManyMailboxAccountInput[]
    skipDuplicates?: boolean
  }

  export type CleanupJobCreateWithoutMailboxAccountInput = {
    id?: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutJobsInput
    unsubscribeAttempts?: UnsubscribeAttemptCreateNestedManyWithoutJobInput
    events?: CleanupJobEventCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUncheckedCreateWithoutMailboxAccountInput = {
    id?: string
    tenantId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedCreateNestedManyWithoutJobInput
    events?: CleanupJobEventUncheckedCreateNestedManyWithoutJobInput
  }

  export type CleanupJobCreateOrConnectWithoutMailboxAccountInput = {
    where: CleanupJobWhereUniqueInput
    create: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput>
  }

  export type CleanupJobCreateManyMailboxAccountInputEnvelope = {
    data: CleanupJobCreateManyMailboxAccountInput | CleanupJobCreateManyMailboxAccountInput[]
    skipDuplicates?: boolean
  }

  export type TenantUpsertWithoutMailboxAccountsInput = {
    update: XOR<TenantUpdateWithoutMailboxAccountsInput, TenantUncheckedUpdateWithoutMailboxAccountsInput>
    create: XOR<TenantCreateWithoutMailboxAccountsInput, TenantUncheckedCreateWithoutMailboxAccountsInput>
    where?: TenantWhereInput
  }

  export type TenantUpdateToOneWithWhereWithoutMailboxAccountsInput = {
    where?: TenantWhereInput
    data: XOR<TenantUpdateWithoutMailboxAccountsInput, TenantUncheckedUpdateWithoutMailboxAccountsInput>
  }

  export type TenantUpdateWithoutMailboxAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUpdateManyWithoutTenantNestedInput
    users?: UserUpdateManyWithoutTenantNestedInput
    rules?: RuleUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateWithoutMailboxAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUncheckedUpdateManyWithoutTenantNestedInput
    users?: UserUncheckedUpdateManyWithoutTenantNestedInput
    rules?: RuleUncheckedUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type MailboxFolderUpsertWithWhereUniqueWithoutMailboxAccountInput = {
    where: MailboxFolderWhereUniqueInput
    update: XOR<MailboxFolderUpdateWithoutMailboxAccountInput, MailboxFolderUncheckedUpdateWithoutMailboxAccountInput>
    create: XOR<MailboxFolderCreateWithoutMailboxAccountInput, MailboxFolderUncheckedCreateWithoutMailboxAccountInput>
  }

  export type MailboxFolderUpdateWithWhereUniqueWithoutMailboxAccountInput = {
    where: MailboxFolderWhereUniqueInput
    data: XOR<MailboxFolderUpdateWithoutMailboxAccountInput, MailboxFolderUncheckedUpdateWithoutMailboxAccountInput>
  }

  export type MailboxFolderUpdateManyWithWhereWithoutMailboxAccountInput = {
    where: MailboxFolderScalarWhereInput
    data: XOR<MailboxFolderUpdateManyMutationInput, MailboxFolderUncheckedUpdateManyWithoutMailboxAccountInput>
  }

  export type MailboxFolderScalarWhereInput = {
    AND?: MailboxFolderScalarWhereInput | MailboxFolderScalarWhereInput[]
    OR?: MailboxFolderScalarWhereInput[]
    NOT?: MailboxFolderScalarWhereInput | MailboxFolderScalarWhereInput[]
    id?: StringFilter<"MailboxFolder"> | string
    mailboxAccountId?: StringFilter<"MailboxFolder"> | string
    name?: StringFilter<"MailboxFolder"> | string
    remoteId?: StringNullableFilter<"MailboxFolder"> | string | null
    createdAt?: DateTimeFilter<"MailboxFolder"> | Date | string
    updatedAt?: DateTimeFilter<"MailboxFolder"> | Date | string
  }

  export type CleanupJobUpsertWithWhereUniqueWithoutMailboxAccountInput = {
    where: CleanupJobWhereUniqueInput
    update: XOR<CleanupJobUpdateWithoutMailboxAccountInput, CleanupJobUncheckedUpdateWithoutMailboxAccountInput>
    create: XOR<CleanupJobCreateWithoutMailboxAccountInput, CleanupJobUncheckedCreateWithoutMailboxAccountInput>
  }

  export type CleanupJobUpdateWithWhereUniqueWithoutMailboxAccountInput = {
    where: CleanupJobWhereUniqueInput
    data: XOR<CleanupJobUpdateWithoutMailboxAccountInput, CleanupJobUncheckedUpdateWithoutMailboxAccountInput>
  }

  export type CleanupJobUpdateManyWithWhereWithoutMailboxAccountInput = {
    where: CleanupJobScalarWhereInput
    data: XOR<CleanupJobUpdateManyMutationInput, CleanupJobUncheckedUpdateManyWithoutMailboxAccountInput>
  }

  export type MailboxAccountCreateWithoutFoldersInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutMailboxAccountsInput
    jobs?: CleanupJobCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountUncheckedCreateWithoutFoldersInput = {
    id?: string
    tenantId: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountCreateOrConnectWithoutFoldersInput = {
    where: MailboxAccountWhereUniqueInput
    create: XOR<MailboxAccountCreateWithoutFoldersInput, MailboxAccountUncheckedCreateWithoutFoldersInput>
  }

  export type MailItemCreateWithoutFolderInput = {
    id?: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailItemUncheckedCreateWithoutFolderInput = {
    id?: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailItemCreateOrConnectWithoutFolderInput = {
    where: MailItemWhereUniqueInput
    create: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput>
  }

  export type MailItemCreateManyFolderInputEnvelope = {
    data: MailItemCreateManyFolderInput | MailItemCreateManyFolderInput[]
    skipDuplicates?: boolean
  }

  export type MailboxAccountUpsertWithoutFoldersInput = {
    update: XOR<MailboxAccountUpdateWithoutFoldersInput, MailboxAccountUncheckedUpdateWithoutFoldersInput>
    create: XOR<MailboxAccountCreateWithoutFoldersInput, MailboxAccountUncheckedCreateWithoutFoldersInput>
    where?: MailboxAccountWhereInput
  }

  export type MailboxAccountUpdateToOneWithWhereWithoutFoldersInput = {
    where?: MailboxAccountWhereInput
    data: XOR<MailboxAccountUpdateWithoutFoldersInput, MailboxAccountUncheckedUpdateWithoutFoldersInput>
  }

  export type MailboxAccountUpdateWithoutFoldersInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutMailboxAccountsNestedInput
    jobs?: CleanupJobUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountUncheckedUpdateWithoutFoldersInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    jobs?: CleanupJobUncheckedUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailItemUpsertWithWhereUniqueWithoutFolderInput = {
    where: MailItemWhereUniqueInput
    update: XOR<MailItemUpdateWithoutFolderInput, MailItemUncheckedUpdateWithoutFolderInput>
    create: XOR<MailItemCreateWithoutFolderInput, MailItemUncheckedCreateWithoutFolderInput>
  }

  export type MailItemUpdateWithWhereUniqueWithoutFolderInput = {
    where: MailItemWhereUniqueInput
    data: XOR<MailItemUpdateWithoutFolderInput, MailItemUncheckedUpdateWithoutFolderInput>
  }

  export type MailItemUpdateManyWithWhereWithoutFolderInput = {
    where: MailItemScalarWhereInput
    data: XOR<MailItemUpdateManyMutationInput, MailItemUncheckedUpdateManyWithoutFolderInput>
  }

  export type MailItemScalarWhereInput = {
    AND?: MailItemScalarWhereInput | MailItemScalarWhereInput[]
    OR?: MailItemScalarWhereInput[]
    NOT?: MailItemScalarWhereInput | MailItemScalarWhereInput[]
    id?: StringFilter<"MailItem"> | string
    folderId?: StringFilter<"MailItem"> | string
    messageId?: StringFilter<"MailItem"> | string
    subject?: StringNullableFilter<"MailItem"> | string | null
    from?: StringNullableFilter<"MailItem"> | string | null
    receivedAt?: DateTimeNullableFilter<"MailItem"> | Date | string | null
    listId?: StringNullableFilter<"MailItem"> | string | null
    listUnsubscribe?: StringNullableFilter<"MailItem"> | string | null
    createdAt?: DateTimeFilter<"MailItem"> | Date | string
    updatedAt?: DateTimeFilter<"MailItem"> | Date | string
  }

  export type MailboxFolderCreateWithoutMailItemsInput = {
    id?: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    mailboxAccount: MailboxAccountCreateNestedOneWithoutFoldersInput
  }

  export type MailboxFolderUncheckedCreateWithoutMailItemsInput = {
    id?: string
    mailboxAccountId: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailboxFolderCreateOrConnectWithoutMailItemsInput = {
    where: MailboxFolderWhereUniqueInput
    create: XOR<MailboxFolderCreateWithoutMailItemsInput, MailboxFolderUncheckedCreateWithoutMailItemsInput>
  }

  export type MailboxFolderUpsertWithoutMailItemsInput = {
    update: XOR<MailboxFolderUpdateWithoutMailItemsInput, MailboxFolderUncheckedUpdateWithoutMailItemsInput>
    create: XOR<MailboxFolderCreateWithoutMailItemsInput, MailboxFolderUncheckedCreateWithoutMailItemsInput>
    where?: MailboxFolderWhereInput
  }

  export type MailboxFolderUpdateToOneWithWhereWithoutMailItemsInput = {
    where?: MailboxFolderWhereInput
    data: XOR<MailboxFolderUpdateWithoutMailItemsInput, MailboxFolderUncheckedUpdateWithoutMailItemsInput>
  }

  export type MailboxFolderUpdateWithoutMailItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutFoldersNestedInput
  }

  export type MailboxFolderUncheckedUpdateWithoutMailItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TenantCreateWithoutRulesInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobCreateNestedManyWithoutTenantInput
    users?: UserCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateWithoutRulesInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobUncheckedCreateNestedManyWithoutTenantInput
    users?: UserUncheckedCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountUncheckedCreateNestedManyWithoutTenantInput
    jobs?: CleanupJobUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantCreateOrConnectWithoutRulesInput = {
    where: TenantWhereUniqueInput
    create: XOR<TenantCreateWithoutRulesInput, TenantUncheckedCreateWithoutRulesInput>
  }

  export type RuleConditionCreateWithoutRuleInput = {
    id?: string
    type: $Enums.RuleConditionType
    value: string
  }

  export type RuleConditionUncheckedCreateWithoutRuleInput = {
    id?: string
    type: $Enums.RuleConditionType
    value: string
  }

  export type RuleConditionCreateOrConnectWithoutRuleInput = {
    where: RuleConditionWhereUniqueInput
    create: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput>
  }

  export type RuleConditionCreateManyRuleInputEnvelope = {
    data: RuleConditionCreateManyRuleInput | RuleConditionCreateManyRuleInput[]
    skipDuplicates?: boolean
  }

  export type RuleActionCreateWithoutRuleInput = {
    id?: string
    type: $Enums.RuleActionType
    target?: string | null
  }

  export type RuleActionUncheckedCreateWithoutRuleInput = {
    id?: string
    type: $Enums.RuleActionType
    target?: string | null
  }

  export type RuleActionCreateOrConnectWithoutRuleInput = {
    where: RuleActionWhereUniqueInput
    create: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput>
  }

  export type RuleActionCreateManyRuleInputEnvelope = {
    data: RuleActionCreateManyRuleInput | RuleActionCreateManyRuleInput[]
    skipDuplicates?: boolean
  }

  export type TenantUpsertWithoutRulesInput = {
    update: XOR<TenantUpdateWithoutRulesInput, TenantUncheckedUpdateWithoutRulesInput>
    create: XOR<TenantCreateWithoutRulesInput, TenantUncheckedCreateWithoutRulesInput>
    where?: TenantWhereInput
  }

  export type TenantUpdateToOneWithWhereWithoutRulesInput = {
    where?: TenantWhereInput
    data: XOR<TenantUpdateWithoutRulesInput, TenantUncheckedUpdateWithoutRulesInput>
  }

  export type TenantUpdateWithoutRulesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUpdateManyWithoutTenantNestedInput
    users?: UserUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateWithoutRulesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUncheckedUpdateManyWithoutTenantNestedInput
    users?: UserUncheckedUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type RuleConditionUpsertWithWhereUniqueWithoutRuleInput = {
    where: RuleConditionWhereUniqueInput
    update: XOR<RuleConditionUpdateWithoutRuleInput, RuleConditionUncheckedUpdateWithoutRuleInput>
    create: XOR<RuleConditionCreateWithoutRuleInput, RuleConditionUncheckedCreateWithoutRuleInput>
  }

  export type RuleConditionUpdateWithWhereUniqueWithoutRuleInput = {
    where: RuleConditionWhereUniqueInput
    data: XOR<RuleConditionUpdateWithoutRuleInput, RuleConditionUncheckedUpdateWithoutRuleInput>
  }

  export type RuleConditionUpdateManyWithWhereWithoutRuleInput = {
    where: RuleConditionScalarWhereInput
    data: XOR<RuleConditionUpdateManyMutationInput, RuleConditionUncheckedUpdateManyWithoutRuleInput>
  }

  export type RuleConditionScalarWhereInput = {
    AND?: RuleConditionScalarWhereInput | RuleConditionScalarWhereInput[]
    OR?: RuleConditionScalarWhereInput[]
    NOT?: RuleConditionScalarWhereInput | RuleConditionScalarWhereInput[]
    id?: StringFilter<"RuleCondition"> | string
    ruleId?: StringFilter<"RuleCondition"> | string
    type?: EnumRuleConditionTypeFilter<"RuleCondition"> | $Enums.RuleConditionType
    value?: StringFilter<"RuleCondition"> | string
  }

  export type RuleActionUpsertWithWhereUniqueWithoutRuleInput = {
    where: RuleActionWhereUniqueInput
    update: XOR<RuleActionUpdateWithoutRuleInput, RuleActionUncheckedUpdateWithoutRuleInput>
    create: XOR<RuleActionCreateWithoutRuleInput, RuleActionUncheckedCreateWithoutRuleInput>
  }

  export type RuleActionUpdateWithWhereUniqueWithoutRuleInput = {
    where: RuleActionWhereUniqueInput
    data: XOR<RuleActionUpdateWithoutRuleInput, RuleActionUncheckedUpdateWithoutRuleInput>
  }

  export type RuleActionUpdateManyWithWhereWithoutRuleInput = {
    where: RuleActionScalarWhereInput
    data: XOR<RuleActionUpdateManyMutationInput, RuleActionUncheckedUpdateManyWithoutRuleInput>
  }

  export type RuleActionScalarWhereInput = {
    AND?: RuleActionScalarWhereInput | RuleActionScalarWhereInput[]
    OR?: RuleActionScalarWhereInput[]
    NOT?: RuleActionScalarWhereInput | RuleActionScalarWhereInput[]
    id?: StringFilter<"RuleAction"> | string
    ruleId?: StringFilter<"RuleAction"> | string
    type?: EnumRuleActionTypeFilter<"RuleAction"> | $Enums.RuleActionType
    target?: StringNullableFilter<"RuleAction"> | string | null
  }

  export type RuleCreateWithoutConditionsInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutRulesInput
    actions?: RuleActionCreateNestedManyWithoutRuleInput
  }

  export type RuleUncheckedCreateWithoutConditionsInput = {
    id?: string
    tenantId: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    actions?: RuleActionUncheckedCreateNestedManyWithoutRuleInput
  }

  export type RuleCreateOrConnectWithoutConditionsInput = {
    where: RuleWhereUniqueInput
    create: XOR<RuleCreateWithoutConditionsInput, RuleUncheckedCreateWithoutConditionsInput>
  }

  export type RuleUpsertWithoutConditionsInput = {
    update: XOR<RuleUpdateWithoutConditionsInput, RuleUncheckedUpdateWithoutConditionsInput>
    create: XOR<RuleCreateWithoutConditionsInput, RuleUncheckedCreateWithoutConditionsInput>
    where?: RuleWhereInput
  }

  export type RuleUpdateToOneWithWhereWithoutConditionsInput = {
    where?: RuleWhereInput
    data: XOR<RuleUpdateWithoutConditionsInput, RuleUncheckedUpdateWithoutConditionsInput>
  }

  export type RuleUpdateWithoutConditionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutRulesNestedInput
    actions?: RuleActionUpdateManyWithoutRuleNestedInput
  }

  export type RuleUncheckedUpdateWithoutConditionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actions?: RuleActionUncheckedUpdateManyWithoutRuleNestedInput
  }

  export type RuleCreateWithoutActionsInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutRulesInput
    conditions?: RuleConditionCreateNestedManyWithoutRuleInput
  }

  export type RuleUncheckedCreateWithoutActionsInput = {
    id?: string
    tenantId: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    conditions?: RuleConditionUncheckedCreateNestedManyWithoutRuleInput
  }

  export type RuleCreateOrConnectWithoutActionsInput = {
    where: RuleWhereUniqueInput
    create: XOR<RuleCreateWithoutActionsInput, RuleUncheckedCreateWithoutActionsInput>
  }

  export type RuleUpsertWithoutActionsInput = {
    update: XOR<RuleUpdateWithoutActionsInput, RuleUncheckedUpdateWithoutActionsInput>
    create: XOR<RuleCreateWithoutActionsInput, RuleUncheckedCreateWithoutActionsInput>
    where?: RuleWhereInput
  }

  export type RuleUpdateToOneWithWhereWithoutActionsInput = {
    where?: RuleWhereInput
    data: XOR<RuleUpdateWithoutActionsInput, RuleUncheckedUpdateWithoutActionsInput>
  }

  export type RuleUpdateWithoutActionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutRulesNestedInput
    conditions?: RuleConditionUpdateManyWithoutRuleNestedInput
  }

  export type RuleUncheckedUpdateWithoutActionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    conditions?: RuleConditionUncheckedUpdateManyWithoutRuleNestedInput
  }

  export type TenantCreateWithoutJobsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobCreateNestedManyWithoutTenantInput
    users?: UserCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountCreateNestedManyWithoutTenantInput
    rules?: RuleCreateNestedManyWithoutTenantInput
  }

  export type TenantUncheckedCreateWithoutJobsInput = {
    id?: string
    name: string
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    exportJobs?: ExportJobUncheckedCreateNestedManyWithoutTenantInput
    users?: UserUncheckedCreateNestedManyWithoutTenantInput
    mailboxAccounts?: MailboxAccountUncheckedCreateNestedManyWithoutTenantInput
    rules?: RuleUncheckedCreateNestedManyWithoutTenantInput
  }

  export type TenantCreateOrConnectWithoutJobsInput = {
    where: TenantWhereUniqueInput
    create: XOR<TenantCreateWithoutJobsInput, TenantUncheckedCreateWithoutJobsInput>
  }

  export type MailboxAccountCreateWithoutJobsInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutMailboxAccountsInput
    folders?: MailboxFolderCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountUncheckedCreateWithoutJobsInput = {
    id?: string
    tenantId: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    folders?: MailboxFolderUncheckedCreateNestedManyWithoutMailboxAccountInput
  }

  export type MailboxAccountCreateOrConnectWithoutJobsInput = {
    where: MailboxAccountWhereUniqueInput
    create: XOR<MailboxAccountCreateWithoutJobsInput, MailboxAccountUncheckedCreateWithoutJobsInput>
  }

  export type UnsubscribeAttemptCreateWithoutJobInput = {
    id?: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
  }

  export type UnsubscribeAttemptUncheckedCreateWithoutJobInput = {
    id?: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
  }

  export type UnsubscribeAttemptCreateOrConnectWithoutJobInput = {
    where: UnsubscribeAttemptWhereUniqueInput
    create: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput>
  }

  export type UnsubscribeAttemptCreateManyJobInputEnvelope = {
    data: UnsubscribeAttemptCreateManyJobInput | UnsubscribeAttemptCreateManyJobInput[]
    skipDuplicates?: boolean
  }

  export type CleanupJobEventCreateWithoutJobInput = {
    id?: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
  }

  export type CleanupJobEventUncheckedCreateWithoutJobInput = {
    id?: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
  }

  export type CleanupJobEventCreateOrConnectWithoutJobInput = {
    where: CleanupJobEventWhereUniqueInput
    create: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput>
  }

  export type CleanupJobEventCreateManyJobInputEnvelope = {
    data: CleanupJobEventCreateManyJobInput | CleanupJobEventCreateManyJobInput[]
    skipDuplicates?: boolean
  }

  export type TenantUpsertWithoutJobsInput = {
    update: XOR<TenantUpdateWithoutJobsInput, TenantUncheckedUpdateWithoutJobsInput>
    create: XOR<TenantCreateWithoutJobsInput, TenantUncheckedCreateWithoutJobsInput>
    where?: TenantWhereInput
  }

  export type TenantUpdateToOneWithWhereWithoutJobsInput = {
    where?: TenantWhereInput
    data: XOR<TenantUpdateWithoutJobsInput, TenantUncheckedUpdateWithoutJobsInput>
  }

  export type TenantUpdateWithoutJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUpdateManyWithoutTenantNestedInput
    users?: UserUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUpdateManyWithoutTenantNestedInput
    rules?: RuleUpdateManyWithoutTenantNestedInput
  }

  export type TenantUncheckedUpdateWithoutJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    exportJobs?: ExportJobUncheckedUpdateManyWithoutTenantNestedInput
    users?: UserUncheckedUpdateManyWithoutTenantNestedInput
    mailboxAccounts?: MailboxAccountUncheckedUpdateManyWithoutTenantNestedInput
    rules?: RuleUncheckedUpdateManyWithoutTenantNestedInput
  }

  export type MailboxAccountUpsertWithoutJobsInput = {
    update: XOR<MailboxAccountUpdateWithoutJobsInput, MailboxAccountUncheckedUpdateWithoutJobsInput>
    create: XOR<MailboxAccountCreateWithoutJobsInput, MailboxAccountUncheckedCreateWithoutJobsInput>
    where?: MailboxAccountWhereInput
  }

  export type MailboxAccountUpdateToOneWithWhereWithoutJobsInput = {
    where?: MailboxAccountWhereInput
    data: XOR<MailboxAccountUpdateWithoutJobsInput, MailboxAccountUncheckedUpdateWithoutJobsInput>
  }

  export type MailboxAccountUpdateWithoutJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutMailboxAccountsNestedInput
    folders?: MailboxFolderUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountUncheckedUpdateWithoutJobsInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folders?: MailboxFolderUncheckedUpdateManyWithoutMailboxAccountNestedInput
  }

  export type UnsubscribeAttemptUpsertWithWhereUniqueWithoutJobInput = {
    where: UnsubscribeAttemptWhereUniqueInput
    update: XOR<UnsubscribeAttemptUpdateWithoutJobInput, UnsubscribeAttemptUncheckedUpdateWithoutJobInput>
    create: XOR<UnsubscribeAttemptCreateWithoutJobInput, UnsubscribeAttemptUncheckedCreateWithoutJobInput>
  }

  export type UnsubscribeAttemptUpdateWithWhereUniqueWithoutJobInput = {
    where: UnsubscribeAttemptWhereUniqueInput
    data: XOR<UnsubscribeAttemptUpdateWithoutJobInput, UnsubscribeAttemptUncheckedUpdateWithoutJobInput>
  }

  export type UnsubscribeAttemptUpdateManyWithWhereWithoutJobInput = {
    where: UnsubscribeAttemptScalarWhereInput
    data: XOR<UnsubscribeAttemptUpdateManyMutationInput, UnsubscribeAttemptUncheckedUpdateManyWithoutJobInput>
  }

  export type UnsubscribeAttemptScalarWhereInput = {
    AND?: UnsubscribeAttemptScalarWhereInput | UnsubscribeAttemptScalarWhereInput[]
    OR?: UnsubscribeAttemptScalarWhereInput[]
    NOT?: UnsubscribeAttemptScalarWhereInput | UnsubscribeAttemptScalarWhereInput[]
    id?: StringFilter<"UnsubscribeAttempt"> | string
    jobId?: StringFilter<"UnsubscribeAttempt"> | string
    mailItemId?: StringNullableFilter<"UnsubscribeAttempt"> | string | null
    method?: StringFilter<"UnsubscribeAttempt"> | string
    target?: StringFilter<"UnsubscribeAttempt"> | string
    status?: StringFilter<"UnsubscribeAttempt"> | string
    createdAt?: DateTimeFilter<"UnsubscribeAttempt"> | Date | string
  }

  export type CleanupJobEventUpsertWithWhereUniqueWithoutJobInput = {
    where: CleanupJobEventWhereUniqueInput
    update: XOR<CleanupJobEventUpdateWithoutJobInput, CleanupJobEventUncheckedUpdateWithoutJobInput>
    create: XOR<CleanupJobEventCreateWithoutJobInput, CleanupJobEventUncheckedCreateWithoutJobInput>
  }

  export type CleanupJobEventUpdateWithWhereUniqueWithoutJobInput = {
    where: CleanupJobEventWhereUniqueInput
    data: XOR<CleanupJobEventUpdateWithoutJobInput, CleanupJobEventUncheckedUpdateWithoutJobInput>
  }

  export type CleanupJobEventUpdateManyWithWhereWithoutJobInput = {
    where: CleanupJobEventScalarWhereInput
    data: XOR<CleanupJobEventUpdateManyMutationInput, CleanupJobEventUncheckedUpdateManyWithoutJobInput>
  }

  export type CleanupJobEventScalarWhereInput = {
    AND?: CleanupJobEventScalarWhereInput | CleanupJobEventScalarWhereInput[]
    OR?: CleanupJobEventScalarWhereInput[]
    NOT?: CleanupJobEventScalarWhereInput | CleanupJobEventScalarWhereInput[]
    id?: StringFilter<"CleanupJobEvent"> | string
    jobId?: StringFilter<"CleanupJobEvent"> | string
    level?: StringFilter<"CleanupJobEvent"> | string
    message?: StringFilter<"CleanupJobEvent"> | string
    progress?: IntNullableFilter<"CleanupJobEvent"> | number | null
    createdAt?: DateTimeFilter<"CleanupJobEvent"> | Date | string
  }

  export type CleanupJobCreateWithoutUnsubscribeAttemptsInput = {
    id?: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutJobsInput
    mailboxAccount: MailboxAccountCreateNestedOneWithoutJobsInput
    events?: CleanupJobEventCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUncheckedCreateWithoutUnsubscribeAttemptsInput = {
    id?: string
    tenantId: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    events?: CleanupJobEventUncheckedCreateNestedManyWithoutJobInput
  }

  export type CleanupJobCreateOrConnectWithoutUnsubscribeAttemptsInput = {
    where: CleanupJobWhereUniqueInput
    create: XOR<CleanupJobCreateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedCreateWithoutUnsubscribeAttemptsInput>
  }

  export type CleanupJobUpsertWithoutUnsubscribeAttemptsInput = {
    update: XOR<CleanupJobUpdateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedUpdateWithoutUnsubscribeAttemptsInput>
    create: XOR<CleanupJobCreateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedCreateWithoutUnsubscribeAttemptsInput>
    where?: CleanupJobWhereInput
  }

  export type CleanupJobUpdateToOneWithWhereWithoutUnsubscribeAttemptsInput = {
    where?: CleanupJobWhereInput
    data: XOR<CleanupJobUpdateWithoutUnsubscribeAttemptsInput, CleanupJobUncheckedUpdateWithoutUnsubscribeAttemptsInput>
  }

  export type CleanupJobUpdateWithoutUnsubscribeAttemptsInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutJobsNestedInput
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutJobsNestedInput
    events?: CleanupJobEventUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateWithoutUnsubscribeAttemptsInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    events?: CleanupJobEventUncheckedUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobCreateWithoutEventsInput = {
    id?: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    tenant: TenantCreateNestedOneWithoutJobsInput
    mailboxAccount: MailboxAccountCreateNestedOneWithoutJobsInput
    unsubscribeAttempts?: UnsubscribeAttemptCreateNestedManyWithoutJobInput
  }

  export type CleanupJobUncheckedCreateWithoutEventsInput = {
    id?: string
    tenantId: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedCreateNestedManyWithoutJobInput
  }

  export type CleanupJobCreateOrConnectWithoutEventsInput = {
    where: CleanupJobWhereUniqueInput
    create: XOR<CleanupJobCreateWithoutEventsInput, CleanupJobUncheckedCreateWithoutEventsInput>
  }

  export type CleanupJobUpsertWithoutEventsInput = {
    update: XOR<CleanupJobUpdateWithoutEventsInput, CleanupJobUncheckedUpdateWithoutEventsInput>
    create: XOR<CleanupJobCreateWithoutEventsInput, CleanupJobUncheckedCreateWithoutEventsInput>
    where?: CleanupJobWhereInput
  }

  export type CleanupJobUpdateToOneWithWhereWithoutEventsInput = {
    where?: CleanupJobWhereInput
    data: XOR<CleanupJobUpdateWithoutEventsInput, CleanupJobUncheckedUpdateWithoutEventsInput>
  }

  export type CleanupJobUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutJobsNestedInput
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutJobsNestedInput
    unsubscribeAttempts?: UnsubscribeAttemptUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedUpdateManyWithoutJobNestedInput
  }

  export type ExportJobCreateManyTenantInput = {
    id?: string
    status?: $Enums.ExportStatus
    format: string
    scope: string
    filePath?: string | null
    error?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserCreateManyTenantInput = {
    id?: string
    email: string
    password: string
    role?: $Enums.UserRole
    isActive?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailboxAccountCreateManyTenantInput = {
    id?: string
    email: string
    provider: $Enums.MailProvider
    isActive?: boolean
    imapHost: string
    imapPort: number
    imapTLS: boolean
    smtpHost?: string | null
    smtpPort?: number | null
    smtpTLS?: boolean | null
    oauthToken?: string | null
    oauthRefreshToken?: string | null
    oauthAccessToken?: string | null
    oauthExpiresAt?: Date | string | null
    providerUserId?: string | null
    appPassword?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type RuleCreateManyTenantInput = {
    id?: string
    name: string
    enabled?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CleanupJobCreateManyTenantInput = {
    id?: string
    mailboxAccountId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ExportJobUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExportJobUncheckedUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExportJobUncheckedUpdateManyWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumExportStatusFieldUpdateOperationsInput | $Enums.ExportStatus
    format?: StringFieldUpdateOperationsInput | string
    scope?: StringFieldUpdateOperationsInput | string
    filePath?: NullableStringFieldUpdateOperationsInput | string | null
    error?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxAccountUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folders?: MailboxFolderUpdateManyWithoutMailboxAccountNestedInput
    jobs?: CleanupJobUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountUncheckedUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    folders?: MailboxFolderUncheckedUpdateManyWithoutMailboxAccountNestedInput
    jobs?: CleanupJobUncheckedUpdateManyWithoutMailboxAccountNestedInput
  }

  export type MailboxAccountUncheckedUpdateManyWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    provider?: EnumMailProviderFieldUpdateOperationsInput | $Enums.MailProvider
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imapHost?: StringFieldUpdateOperationsInput | string
    imapPort?: IntFieldUpdateOperationsInput | number
    imapTLS?: BoolFieldUpdateOperationsInput | boolean
    smtpHost?: NullableStringFieldUpdateOperationsInput | string | null
    smtpPort?: NullableIntFieldUpdateOperationsInput | number | null
    smtpTLS?: NullableBoolFieldUpdateOperationsInput | boolean | null
    oauthToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthRefreshToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthAccessToken?: NullableStringFieldUpdateOperationsInput | string | null
    oauthExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    providerUserId?: NullableStringFieldUpdateOperationsInput | string | null
    appPassword?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RuleUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    conditions?: RuleConditionUpdateManyWithoutRuleNestedInput
    actions?: RuleActionUpdateManyWithoutRuleNestedInput
  }

  export type RuleUncheckedUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    conditions?: RuleConditionUncheckedUpdateManyWithoutRuleNestedInput
    actions?: RuleActionUncheckedUpdateManyWithoutRuleNestedInput
  }

  export type RuleUncheckedUpdateManyWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    enabled?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailboxAccount?: MailboxAccountUpdateOneRequiredWithoutJobsNestedInput
    unsubscribeAttempts?: UnsubscribeAttemptUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUncheckedUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateManyWithoutTenantInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailboxAccountId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailboxFolderCreateManyMailboxAccountInput = {
    id?: string
    name: string
    remoteId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CleanupJobCreateManyMailboxAccountInput = {
    id?: string
    tenantId: string
    status?: $Enums.JobStatus
    dryRun?: boolean
    unsubscribeEnabled?: boolean
    routingEnabled?: boolean
    startedAt?: Date | string | null
    finishedAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailboxFolderUpdateWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailItems?: MailItemUpdateManyWithoutFolderNestedInput
  }

  export type MailboxFolderUncheckedUpdateWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    mailItems?: MailItemUncheckedUpdateManyWithoutFolderNestedInput
  }

  export type MailboxFolderUncheckedUpdateManyWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    remoteId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobUpdateWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tenant?: TenantUpdateOneRequiredWithoutJobsNestedInput
    unsubscribeAttempts?: UnsubscribeAttemptUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    unsubscribeAttempts?: UnsubscribeAttemptUncheckedUpdateManyWithoutJobNestedInput
    events?: CleanupJobEventUncheckedUpdateManyWithoutJobNestedInput
  }

  export type CleanupJobUncheckedUpdateManyWithoutMailboxAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    tenantId?: StringFieldUpdateOperationsInput | string
    status?: EnumJobStatusFieldUpdateOperationsInput | $Enums.JobStatus
    dryRun?: BoolFieldUpdateOperationsInput | boolean
    unsubscribeEnabled?: BoolFieldUpdateOperationsInput | boolean
    routingEnabled?: BoolFieldUpdateOperationsInput | boolean
    startedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    finishedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemCreateManyFolderInput = {
    id?: string
    messageId: string
    subject?: string | null
    from?: string | null
    receivedAt?: Date | string | null
    listId?: string | null
    listUnsubscribe?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MailItemUpdateWithoutFolderInput = {
    id?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemUncheckedUpdateWithoutFolderInput = {
    id?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MailItemUncheckedUpdateManyWithoutFolderInput = {
    id?: StringFieldUpdateOperationsInput | string
    messageId?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    from?: NullableStringFieldUpdateOperationsInput | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    listId?: NullableStringFieldUpdateOperationsInput | string | null
    listUnsubscribe?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RuleConditionCreateManyRuleInput = {
    id?: string
    type: $Enums.RuleConditionType
    value: string
  }

  export type RuleActionCreateManyRuleInput = {
    id?: string
    type: $Enums.RuleActionType
    target?: string | null
  }

  export type RuleConditionUpdateWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleConditionUncheckedUpdateWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleConditionUncheckedUpdateManyWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleConditionTypeFieldUpdateOperationsInput | $Enums.RuleConditionType
    value?: StringFieldUpdateOperationsInput | string
  }

  export type RuleActionUpdateWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RuleActionUncheckedUpdateWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RuleActionUncheckedUpdateManyWithoutRuleInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumRuleActionTypeFieldUpdateOperationsInput | $Enums.RuleActionType
    target?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UnsubscribeAttemptCreateManyJobInput = {
    id?: string
    mailItemId?: string | null
    method: string
    target: string
    status: string
    createdAt?: Date | string
  }

  export type CleanupJobEventCreateManyJobInput = {
    id?: string
    level: string
    message: string
    progress?: number | null
    createdAt?: Date | string
  }

  export type UnsubscribeAttemptUpdateWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UnsubscribeAttemptUncheckedUpdateWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UnsubscribeAttemptUncheckedUpdateManyWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    mailItemId?: NullableStringFieldUpdateOperationsInput | string | null
    method?: StringFieldUpdateOperationsInput | string
    target?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventUpdateWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventUncheckedUpdateWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CleanupJobEventUncheckedUpdateManyWithoutJobInput = {
    id?: StringFieldUpdateOperationsInput | string
    level?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    progress?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use TenantCountOutputTypeDefaultArgs instead
     */
    export type TenantCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TenantCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MailboxAccountCountOutputTypeDefaultArgs instead
     */
    export type MailboxAccountCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MailboxAccountCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MailboxFolderCountOutputTypeDefaultArgs instead
     */
    export type MailboxFolderCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MailboxFolderCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RuleCountOutputTypeDefaultArgs instead
     */
    export type RuleCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RuleCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CleanupJobCountOutputTypeDefaultArgs instead
     */
    export type CleanupJobCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CleanupJobCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TenantDefaultArgs instead
     */
    export type TenantArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TenantDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExportJobDefaultArgs instead
     */
    export type ExportJobArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExportJobDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MailboxAccountDefaultArgs instead
     */
    export type MailboxAccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MailboxAccountDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MailboxFolderDefaultArgs instead
     */
    export type MailboxFolderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MailboxFolderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MailItemDefaultArgs instead
     */
    export type MailItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MailItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RuleDefaultArgs instead
     */
    export type RuleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RuleDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RuleConditionDefaultArgs instead
     */
    export type RuleConditionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RuleConditionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RuleActionDefaultArgs instead
     */
    export type RuleActionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RuleActionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CleanupJobDefaultArgs instead
     */
    export type CleanupJobArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CleanupJobDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UnsubscribeAttemptDefaultArgs instead
     */
    export type UnsubscribeAttemptArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UnsubscribeAttemptDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CleanupJobEventDefaultArgs instead
     */
    export type CleanupJobEventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CleanupJobEventDefaultArgs<ExtArgs>

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

  export type BatchPayload = {
    count: number
  }

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