MIF_E31221222/prisma/generated/prisma-client/index.d.ts

/**
 * Client
**/

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

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


/**
 * Model profiles
 * 
 */
export type profiles = $Result.DefaultSelection<Prisma.$profilesPayload>
/**
 * Model users
 * 
 */
export type users = $Result.DefaultSelection<Prisma.$usersPayload>
/**
 * Model roles
 * 
 */
export type roles = $Result.DefaultSelection<Prisma.$rolesPayload>
/**
 * Model sessions
 * 
 */
export type sessions = $Result.DefaultSelection<Prisma.$sessionsPayload>
/**
 * Model events
 * 
 */
export type events = $Result.DefaultSelection<Prisma.$eventsPayload>
/**
 * Model resources
 * 
 */
export type resources = $Result.DefaultSelection<Prisma.$resourcesPayload>
/**
 * Model permissions
 * 
 */
export type permissions = $Result.DefaultSelection<Prisma.$permissionsPayload>
/**
 * Model cities
 * 
 */
export type cities = $Result.DefaultSelection<Prisma.$citiesPayload>
/**
 * Model crime_incidents
 * 
 */
export type crime_incidents = $Result.DefaultSelection<Prisma.$crime_incidentsPayload>
/**
 * Model crime_categories
 * 
 */
export type crime_categories = $Result.DefaultSelection<Prisma.$crime_categoriesPayload>
/**
 * Model crimes
 * 
 */
export type crimes = $Result.DefaultSelection<Prisma.$crimesPayload>
/**
 * Model demographics
 * 
 */
export type demographics = $Result.DefaultSelection<Prisma.$demographicsPayload>
/**
 * Model districts
 * 
 */
export type districts = $Result.DefaultSelection<Prisma.$districtsPayload>
/**
 * Model locations
 * 
 */
export type locations = $Result.DefaultSelection<Prisma.$locationsPayload>
/**
 * Model incident_logs
 * 
 */
export type incident_logs = $Result.DefaultSelection<Prisma.$incident_logsPayload>
/**
 * Model timelines
 * 
 */
export type timelines = $Result.DefaultSelection<Prisma.$timelinesPayload>
/**
 * Model witnesses
 * 
 */
export type witnesses = $Result.DefaultSelection<Prisma.$witnessesPayload>
/**
 * Model evidence
 * 
 */
export type evidence = $Result.DefaultSelection<Prisma.$evidencePayload>
/**
 * Model units
 * 
 */
export type units = $Result.DefaultSelection<Prisma.$unitsPayload>
/**
 * Model patrol_units
 * 
 */
export type patrol_units = $Result.DefaultSelection<Prisma.$patrol_unitsPayload>
/**
 * Model officers
 * 
 */
export type officers = $Result.DefaultSelection<Prisma.$officersPayload>
/**
 * Model unit_statistics
 * 
 */
export type unit_statistics = $Result.DefaultSelection<Prisma.$unit_statisticsPayload>
/**
 * Model geographics
 * 
 */
export type geographics = $Result.DefaultSelection<Prisma.$geographicsPayload>
/**
 * Model contact_messages
 * 
 */
export type contact_messages = $Result.DefaultSelection<Prisma.$contact_messagesPayload>
/**
 * Model messages
 * 
 */
export type messages = $Result.DefaultSelection<Prisma.$messagesPayload>
/**
 * Model inbox
 * 
 */
export type inbox = $Result.DefaultSelection<Prisma.$inboxPayload>
/**
 * Model logs
 * 
 */
export type logs = $Result.DefaultSelection<Prisma.$logsPayload>
/**
 * Model panic_button_logs
 * 
 */
export type panic_button_logs = $Result.DefaultSelection<Prisma.$panic_button_logsPayload>
/**
 * Model location_logs
 * 
 */
export type location_logs = $Result.DefaultSelection<Prisma.$location_logsPayload>
/**
 * Model district_clusters
 * 
 */
export type district_clusters = $Result.DefaultSelection<Prisma.$district_clustersPayload>
/**
 * Model cluster_updates
 * 
 */
export type cluster_updates = $Result.DefaultSelection<Prisma.$cluster_updatesPayload>
/**
 * Model task
 * 
 */
export type task = $Result.DefaultSelection<Prisma.$taskPayload>
/**
 * Model projects
 * 
 */
export type projects = $Result.DefaultSelection<Prisma.$projectsPayload>
/**
 * Model datasets
 * 
 */
export type datasets = $Result.DefaultSelection<Prisma.$datasetsPayload>
/**
 * Model analyses
 * 
 */
export type analyses = $Result.DefaultSelection<Prisma.$analysesPayload>
/**
 * Model clusters
 * 
 */
export type clusters = $Result.DefaultSelection<Prisma.$clustersPayload>
/**
 * Model analysis_templates
 * 
 */
export type analysis_templates = $Result.DefaultSelection<Prisma.$analysis_templatesPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const task_status: {
  todo: 'todo',
  in_progress: 'in_progress',
  done: 'done',
  canceled: 'canceled'
};

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


export const task_label: {
  report: 'report',
  investigation: 'investigation',
  patrol: 'patrol',
  evidence: 'evidence',
  documentation: 'documentation',
  coordination: 'coordination',
  follow_up: 'follow_up',
  prevention: 'prevention',
  other: 'other'
};

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


export const task_priority: {
  low: 'low',
  medium: 'medium',
  high: 'high'
};

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


export const patrol_unit_category: {
  individual: 'individual',
  group: 'group'
};

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


export const session_status: {
  active: 'active',
  completed: 'completed'
};

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


export const status_messages: {
  new: 'new',
  read: 'read',
  replied: 'replied',
  closed: 'closed'
};

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


export const crime_rates: {
  low: 'low',
  medium: 'medium',
  high: 'high',
  critical: 'critical'
};

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


export const crime_status: {
  open: 'open',
  closed: 'closed',
  under_investigation: 'under_investigation',
  resolved: 'resolved',
  unresolved: 'unresolved'
};

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


export const unit_type: {
  polda: 'polda',
  polsek: 'polsek',
  polres: 'polres',
  other: 'other'
};

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

}

export type task_status = $Enums.task_status

export const task_status: typeof $Enums.task_status

export type task_label = $Enums.task_label

export const task_label: typeof $Enums.task_label

export type task_priority = $Enums.task_priority

export const task_priority: typeof $Enums.task_priority

export type patrol_unit_category = $Enums.patrol_unit_category

export const patrol_unit_category: typeof $Enums.patrol_unit_category

export type session_status = $Enums.session_status

export const session_status: typeof $Enums.session_status

export type status_messages = $Enums.status_messages

export const status_messages: typeof $Enums.status_messages

export type crime_rates = $Enums.crime_rates

export const crime_rates: typeof $Enums.crime_rates

export type crime_status = $Enums.crime_status

export const crime_status: typeof $Enums.crime_status

export type unit_type = $Enums.unit_type

export const unit_type: typeof $Enums.unit_type

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Profiles
 * const profiles = await prisma.profiles.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 Profiles
   * const profiles = await prisma.profiles.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): PrismaClient;

  /**
   * 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<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
    extArgs: ExtArgs
  }>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
   * 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: 6.11.1
   * Query Engine version: f40f79ec31188888a2e33acda0ecc8fd10a853a9
   */
  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 ? P : never]-?: O[P]} & O
    : never>;

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    profiles: 'profiles',
    users: 'users',
    roles: 'roles',
    sessions: 'sessions',
    events: 'events',
    resources: 'resources',
    permissions: 'permissions',
    cities: 'cities',
    crime_incidents: 'crime_incidents',
    crime_categories: 'crime_categories',
    crimes: 'crimes',
    demographics: 'demographics',
    districts: 'districts',
    locations: 'locations',
    incident_logs: 'incident_logs',
    timelines: 'timelines',
    witnesses: 'witnesses',
    evidence: 'evidence',
    units: 'units',
    patrol_units: 'patrol_units',
    officers: 'officers',
    unit_statistics: 'unit_statistics',
    geographics: 'geographics',
    contact_messages: 'contact_messages',
    messages: 'messages',
    inbox: 'inbox',
    logs: 'logs',
    panic_button_logs: 'panic_button_logs',
    location_logs: 'location_logs',
    district_clusters: 'district_clusters',
    cluster_updates: 'cluster_updates',
    task: 'task',
    projects: 'projects',
    datasets: 'datasets',
    analyses: 'analyses',
    clusters: 'clusters',
    analysis_templates: 'analysis_templates'
  };

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


  export type Datasources = {
    db?: Datasource
  }

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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "profiles" | "users" | "roles" | "sessions" | "events" | "resources" | "permissions" | "cities" | "crime_incidents" | "crime_categories" | "crimes" | "demographics" | "districts" | "locations" | "incident_logs" | "timelines" | "witnesses" | "evidence" | "units" | "patrol_units" | "officers" | "unit_statistics" | "geographics" | "contact_messages" | "messages" | "inbox" | "logs" | "panic_button_logs" | "location_logs" | "district_clusters" | "cluster_updates" | "task" | "projects" | "datasets" | "analyses" | "clusters" | "analysis_templates"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      profiles: {
        payload: Prisma.$profilesPayload<ExtArgs>
        fields: Prisma.profilesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.profilesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.profilesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          findFirst: {
            args: Prisma.profilesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.profilesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          findMany: {
            args: Prisma.profilesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>[]
          }
          create: {
            args: Prisma.profilesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          createMany: {
            args: Prisma.profilesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.profilesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>[]
          }
          delete: {
            args: Prisma.profilesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          update: {
            args: Prisma.profilesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          deleteMany: {
            args: Prisma.profilesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.profilesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.profilesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>[]
          }
          upsert: {
            args: Prisma.profilesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$profilesPayload>
          }
          aggregate: {
            args: Prisma.ProfilesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProfiles>
          }
          groupBy: {
            args: Prisma.profilesGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProfilesGroupByOutputType>[]
          }
          count: {
            args: Prisma.profilesCountArgs<ExtArgs>
            result: $Utils.Optional<ProfilesCountAggregateOutputType> | number
          }
        }
      }
      users: {
        payload: Prisma.$usersPayload<ExtArgs>
        fields: Prisma.usersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.usersFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.usersFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          findFirst: {
            args: Prisma.usersFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.usersFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          findMany: {
            args: Prisma.usersFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>[]
          }
          create: {
            args: Prisma.usersCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          createMany: {
            args: Prisma.usersCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.usersCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>[]
          }
          delete: {
            args: Prisma.usersDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          update: {
            args: Prisma.usersUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          deleteMany: {
            args: Prisma.usersDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.usersUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.usersUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>[]
          }
          upsert: {
            args: Prisma.usersUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$usersPayload>
          }
          aggregate: {
            args: Prisma.UsersAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUsers>
          }
          groupBy: {
            args: Prisma.usersGroupByArgs<ExtArgs>
            result: $Utils.Optional<UsersGroupByOutputType>[]
          }
          count: {
            args: Prisma.usersCountArgs<ExtArgs>
            result: $Utils.Optional<UsersCountAggregateOutputType> | number
          }
        }
      }
      roles: {
        payload: Prisma.$rolesPayload<ExtArgs>
        fields: Prisma.rolesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.rolesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.rolesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          findFirst: {
            args: Prisma.rolesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.rolesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          findMany: {
            args: Prisma.rolesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>[]
          }
          create: {
            args: Prisma.rolesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          createMany: {
            args: Prisma.rolesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.rolesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>[]
          }
          delete: {
            args: Prisma.rolesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          update: {
            args: Prisma.rolesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          deleteMany: {
            args: Prisma.rolesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.rolesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.rolesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>[]
          }
          upsert: {
            args: Prisma.rolesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$rolesPayload>
          }
          aggregate: {
            args: Prisma.RolesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRoles>
          }
          groupBy: {
            args: Prisma.rolesGroupByArgs<ExtArgs>
            result: $Utils.Optional<RolesGroupByOutputType>[]
          }
          count: {
            args: Prisma.rolesCountArgs<ExtArgs>
            result: $Utils.Optional<RolesCountAggregateOutputType> | number
          }
        }
      }
      sessions: {
        payload: Prisma.$sessionsPayload<ExtArgs>
        fields: Prisma.sessionsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.sessionsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.sessionsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          findFirst: {
            args: Prisma.sessionsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.sessionsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          findMany: {
            args: Prisma.sessionsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>[]
          }
          create: {
            args: Prisma.sessionsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          createMany: {
            args: Prisma.sessionsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.sessionsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>[]
          }
          delete: {
            args: Prisma.sessionsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          update: {
            args: Prisma.sessionsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          deleteMany: {
            args: Prisma.sessionsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.sessionsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.sessionsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>[]
          }
          upsert: {
            args: Prisma.sessionsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$sessionsPayload>
          }
          aggregate: {
            args: Prisma.SessionsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSessions>
          }
          groupBy: {
            args: Prisma.sessionsGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionsGroupByOutputType>[]
          }
          count: {
            args: Prisma.sessionsCountArgs<ExtArgs>
            result: $Utils.Optional<SessionsCountAggregateOutputType> | number
          }
        }
      }
      events: {
        payload: Prisma.$eventsPayload<ExtArgs>
        fields: Prisma.eventsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.eventsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.eventsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          findFirst: {
            args: Prisma.eventsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.eventsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          findMany: {
            args: Prisma.eventsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>[]
          }
          create: {
            args: Prisma.eventsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          createMany: {
            args: Prisma.eventsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.eventsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>[]
          }
          delete: {
            args: Prisma.eventsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          update: {
            args: Prisma.eventsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          deleteMany: {
            args: Prisma.eventsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.eventsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.eventsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>[]
          }
          upsert: {
            args: Prisma.eventsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$eventsPayload>
          }
          aggregate: {
            args: Prisma.EventsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEvents>
          }
          groupBy: {
            args: Prisma.eventsGroupByArgs<ExtArgs>
            result: $Utils.Optional<EventsGroupByOutputType>[]
          }
          count: {
            args: Prisma.eventsCountArgs<ExtArgs>
            result: $Utils.Optional<EventsCountAggregateOutputType> | number
          }
        }
      }
      resources: {
        payload: Prisma.$resourcesPayload<ExtArgs>
        fields: Prisma.resourcesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.resourcesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.resourcesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          findFirst: {
            args: Prisma.resourcesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.resourcesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          findMany: {
            args: Prisma.resourcesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>[]
          }
          create: {
            args: Prisma.resourcesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          createMany: {
            args: Prisma.resourcesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.resourcesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>[]
          }
          delete: {
            args: Prisma.resourcesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          update: {
            args: Prisma.resourcesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          deleteMany: {
            args: Prisma.resourcesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.resourcesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.resourcesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>[]
          }
          upsert: {
            args: Prisma.resourcesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$resourcesPayload>
          }
          aggregate: {
            args: Prisma.ResourcesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateResources>
          }
          groupBy: {
            args: Prisma.resourcesGroupByArgs<ExtArgs>
            result: $Utils.Optional<ResourcesGroupByOutputType>[]
          }
          count: {
            args: Prisma.resourcesCountArgs<ExtArgs>
            result: $Utils.Optional<ResourcesCountAggregateOutputType> | number
          }
        }
      }
      permissions: {
        payload: Prisma.$permissionsPayload<ExtArgs>
        fields: Prisma.permissionsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.permissionsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.permissionsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          findFirst: {
            args: Prisma.permissionsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.permissionsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          findMany: {
            args: Prisma.permissionsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>[]
          }
          create: {
            args: Prisma.permissionsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          createMany: {
            args: Prisma.permissionsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.permissionsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>[]
          }
          delete: {
            args: Prisma.permissionsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          update: {
            args: Prisma.permissionsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          deleteMany: {
            args: Prisma.permissionsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.permissionsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.permissionsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>[]
          }
          upsert: {
            args: Prisma.permissionsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$permissionsPayload>
          }
          aggregate: {
            args: Prisma.PermissionsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePermissions>
          }
          groupBy: {
            args: Prisma.permissionsGroupByArgs<ExtArgs>
            result: $Utils.Optional<PermissionsGroupByOutputType>[]
          }
          count: {
            args: Prisma.permissionsCountArgs<ExtArgs>
            result: $Utils.Optional<PermissionsCountAggregateOutputType> | number
          }
        }
      }
      cities: {
        payload: Prisma.$citiesPayload<ExtArgs>
        fields: Prisma.citiesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.citiesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.citiesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          findFirst: {
            args: Prisma.citiesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.citiesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          findMany: {
            args: Prisma.citiesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
          }
          create: {
            args: Prisma.citiesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          createMany: {
            args: Prisma.citiesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.citiesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
          }
          delete: {
            args: Prisma.citiesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          update: {
            args: Prisma.citiesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          deleteMany: {
            args: Prisma.citiesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.citiesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.citiesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
          }
          upsert: {
            args: Prisma.citiesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$citiesPayload>
          }
          aggregate: {
            args: Prisma.CitiesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCities>
          }
          groupBy: {
            args: Prisma.citiesGroupByArgs<ExtArgs>
            result: $Utils.Optional<CitiesGroupByOutputType>[]
          }
          count: {
            args: Prisma.citiesCountArgs<ExtArgs>
            result: $Utils.Optional<CitiesCountAggregateOutputType> | number
          }
        }
      }
      crime_incidents: {
        payload: Prisma.$crime_incidentsPayload<ExtArgs>
        fields: Prisma.crime_incidentsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.crime_incidentsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.crime_incidentsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          findFirst: {
            args: Prisma.crime_incidentsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.crime_incidentsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          findMany: {
            args: Prisma.crime_incidentsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>[]
          }
          create: {
            args: Prisma.crime_incidentsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          createMany: {
            args: Prisma.crime_incidentsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.crime_incidentsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>[]
          }
          delete: {
            args: Prisma.crime_incidentsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          update: {
            args: Prisma.crime_incidentsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          deleteMany: {
            args: Prisma.crime_incidentsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.crime_incidentsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.crime_incidentsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>[]
          }
          upsert: {
            args: Prisma.crime_incidentsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_incidentsPayload>
          }
          aggregate: {
            args: Prisma.Crime_incidentsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCrime_incidents>
          }
          groupBy: {
            args: Prisma.crime_incidentsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Crime_incidentsGroupByOutputType>[]
          }
          count: {
            args: Prisma.crime_incidentsCountArgs<ExtArgs>
            result: $Utils.Optional<Crime_incidentsCountAggregateOutputType> | number
          }
        }
      }
      crime_categories: {
        payload: Prisma.$crime_categoriesPayload<ExtArgs>
        fields: Prisma.crime_categoriesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.crime_categoriesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.crime_categoriesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          findFirst: {
            args: Prisma.crime_categoriesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.crime_categoriesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          findMany: {
            args: Prisma.crime_categoriesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>[]
          }
          create: {
            args: Prisma.crime_categoriesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          createMany: {
            args: Prisma.crime_categoriesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.crime_categoriesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>[]
          }
          delete: {
            args: Prisma.crime_categoriesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          update: {
            args: Prisma.crime_categoriesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          deleteMany: {
            args: Prisma.crime_categoriesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.crime_categoriesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.crime_categoriesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>[]
          }
          upsert: {
            args: Prisma.crime_categoriesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crime_categoriesPayload>
          }
          aggregate: {
            args: Prisma.Crime_categoriesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCrime_categories>
          }
          groupBy: {
            args: Prisma.crime_categoriesGroupByArgs<ExtArgs>
            result: $Utils.Optional<Crime_categoriesGroupByOutputType>[]
          }
          count: {
            args: Prisma.crime_categoriesCountArgs<ExtArgs>
            result: $Utils.Optional<Crime_categoriesCountAggregateOutputType> | number
          }
        }
      }
      crimes: {
        payload: Prisma.$crimesPayload<ExtArgs>
        fields: Prisma.crimesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.crimesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.crimesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          findFirst: {
            args: Prisma.crimesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.crimesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          findMany: {
            args: Prisma.crimesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>[]
          }
          create: {
            args: Prisma.crimesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          createMany: {
            args: Prisma.crimesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.crimesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>[]
          }
          delete: {
            args: Prisma.crimesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          update: {
            args: Prisma.crimesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          deleteMany: {
            args: Prisma.crimesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.crimesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.crimesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>[]
          }
          upsert: {
            args: Prisma.crimesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$crimesPayload>
          }
          aggregate: {
            args: Prisma.CrimesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCrimes>
          }
          groupBy: {
            args: Prisma.crimesGroupByArgs<ExtArgs>
            result: $Utils.Optional<CrimesGroupByOutputType>[]
          }
          count: {
            args: Prisma.crimesCountArgs<ExtArgs>
            result: $Utils.Optional<CrimesCountAggregateOutputType> | number
          }
        }
      }
      demographics: {
        payload: Prisma.$demographicsPayload<ExtArgs>
        fields: Prisma.demographicsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.demographicsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.demographicsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          findFirst: {
            args: Prisma.demographicsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.demographicsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          findMany: {
            args: Prisma.demographicsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>[]
          }
          create: {
            args: Prisma.demographicsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          createMany: {
            args: Prisma.demographicsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.demographicsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>[]
          }
          delete: {
            args: Prisma.demographicsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          update: {
            args: Prisma.demographicsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          deleteMany: {
            args: Prisma.demographicsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.demographicsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.demographicsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>[]
          }
          upsert: {
            args: Prisma.demographicsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$demographicsPayload>
          }
          aggregate: {
            args: Prisma.DemographicsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDemographics>
          }
          groupBy: {
            args: Prisma.demographicsGroupByArgs<ExtArgs>
            result: $Utils.Optional<DemographicsGroupByOutputType>[]
          }
          count: {
            args: Prisma.demographicsCountArgs<ExtArgs>
            result: $Utils.Optional<DemographicsCountAggregateOutputType> | number
          }
        }
      }
      districts: {
        payload: Prisma.$districtsPayload<ExtArgs>
        fields: Prisma.districtsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.districtsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.districtsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          findFirst: {
            args: Prisma.districtsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.districtsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          findMany: {
            args: Prisma.districtsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>[]
          }
          create: {
            args: Prisma.districtsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          createMany: {
            args: Prisma.districtsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.districtsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>[]
          }
          delete: {
            args: Prisma.districtsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          update: {
            args: Prisma.districtsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          deleteMany: {
            args: Prisma.districtsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.districtsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.districtsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>[]
          }
          upsert: {
            args: Prisma.districtsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$districtsPayload>
          }
          aggregate: {
            args: Prisma.DistrictsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDistricts>
          }
          groupBy: {
            args: Prisma.districtsGroupByArgs<ExtArgs>
            result: $Utils.Optional<DistrictsGroupByOutputType>[]
          }
          count: {
            args: Prisma.districtsCountArgs<ExtArgs>
            result: $Utils.Optional<DistrictsCountAggregateOutputType> | number
          }
        }
      }
      locations: {
        payload: Prisma.$locationsPayload<ExtArgs>
        fields: Prisma.locationsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.locationsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.locationsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>
          }
          findFirst: {
            args: Prisma.locationsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.locationsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>
          }
          findMany: {
            args: Prisma.locationsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>[]
          }
          delete: {
            args: Prisma.locationsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>
          }
          update: {
            args: Prisma.locationsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>
          }
          deleteMany: {
            args: Prisma.locationsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.locationsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.locationsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$locationsPayload>[]
          }
          aggregate: {
            args: Prisma.LocationsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLocations>
          }
          groupBy: {
            args: Prisma.locationsGroupByArgs<ExtArgs>
            result: $Utils.Optional<LocationsGroupByOutputType>[]
          }
          count: {
            args: Prisma.locationsCountArgs<ExtArgs>
            result: $Utils.Optional<LocationsCountAggregateOutputType> | number
          }
        }
      }
      incident_logs: {
        payload: Prisma.$incident_logsPayload<ExtArgs>
        fields: Prisma.incident_logsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.incident_logsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.incident_logsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          findFirst: {
            args: Prisma.incident_logsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.incident_logsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          findMany: {
            args: Prisma.incident_logsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>[]
          }
          create: {
            args: Prisma.incident_logsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          createMany: {
            args: Prisma.incident_logsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.incident_logsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>[]
          }
          delete: {
            args: Prisma.incident_logsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          update: {
            args: Prisma.incident_logsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          deleteMany: {
            args: Prisma.incident_logsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.incident_logsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.incident_logsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>[]
          }
          upsert: {
            args: Prisma.incident_logsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$incident_logsPayload>
          }
          aggregate: {
            args: Prisma.Incident_logsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateIncident_logs>
          }
          groupBy: {
            args: Prisma.incident_logsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Incident_logsGroupByOutputType>[]
          }
          count: {
            args: Prisma.incident_logsCountArgs<ExtArgs>
            result: $Utils.Optional<Incident_logsCountAggregateOutputType> | number
          }
        }
      }
      timelines: {
        payload: Prisma.$timelinesPayload<ExtArgs>
        fields: Prisma.timelinesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.timelinesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.timelinesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          findFirst: {
            args: Prisma.timelinesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.timelinesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          findMany: {
            args: Prisma.timelinesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>[]
          }
          create: {
            args: Prisma.timelinesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          createMany: {
            args: Prisma.timelinesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.timelinesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>[]
          }
          delete: {
            args: Prisma.timelinesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          update: {
            args: Prisma.timelinesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          deleteMany: {
            args: Prisma.timelinesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.timelinesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.timelinesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>[]
          }
          upsert: {
            args: Prisma.timelinesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$timelinesPayload>
          }
          aggregate: {
            args: Prisma.TimelinesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTimelines>
          }
          groupBy: {
            args: Prisma.timelinesGroupByArgs<ExtArgs>
            result: $Utils.Optional<TimelinesGroupByOutputType>[]
          }
          count: {
            args: Prisma.timelinesCountArgs<ExtArgs>
            result: $Utils.Optional<TimelinesCountAggregateOutputType> | number
          }
        }
      }
      witnesses: {
        payload: Prisma.$witnessesPayload<ExtArgs>
        fields: Prisma.witnessesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.witnessesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.witnessesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          findFirst: {
            args: Prisma.witnessesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.witnessesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          findMany: {
            args: Prisma.witnessesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>[]
          }
          create: {
            args: Prisma.witnessesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          createMany: {
            args: Prisma.witnessesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.witnessesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>[]
          }
          delete: {
            args: Prisma.witnessesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          update: {
            args: Prisma.witnessesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          deleteMany: {
            args: Prisma.witnessesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.witnessesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.witnessesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>[]
          }
          upsert: {
            args: Prisma.witnessesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$witnessesPayload>
          }
          aggregate: {
            args: Prisma.WitnessesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWitnesses>
          }
          groupBy: {
            args: Prisma.witnessesGroupByArgs<ExtArgs>
            result: $Utils.Optional<WitnessesGroupByOutputType>[]
          }
          count: {
            args: Prisma.witnessesCountArgs<ExtArgs>
            result: $Utils.Optional<WitnessesCountAggregateOutputType> | number
          }
        }
      }
      evidence: {
        payload: Prisma.$evidencePayload<ExtArgs>
        fields: Prisma.evidenceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.evidenceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.evidenceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          findFirst: {
            args: Prisma.evidenceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.evidenceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          findMany: {
            args: Prisma.evidenceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>[]
          }
          create: {
            args: Prisma.evidenceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          createMany: {
            args: Prisma.evidenceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.evidenceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>[]
          }
          delete: {
            args: Prisma.evidenceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          update: {
            args: Prisma.evidenceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          deleteMany: {
            args: Prisma.evidenceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.evidenceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.evidenceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>[]
          }
          upsert: {
            args: Prisma.evidenceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$evidencePayload>
          }
          aggregate: {
            args: Prisma.EvidenceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEvidence>
          }
          groupBy: {
            args: Prisma.evidenceGroupByArgs<ExtArgs>
            result: $Utils.Optional<EvidenceGroupByOutputType>[]
          }
          count: {
            args: Prisma.evidenceCountArgs<ExtArgs>
            result: $Utils.Optional<EvidenceCountAggregateOutputType> | number
          }
        }
      }
      units: {
        payload: Prisma.$unitsPayload<ExtArgs>
        fields: Prisma.unitsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.unitsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.unitsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>
          }
          findFirst: {
            args: Prisma.unitsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.unitsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>
          }
          findMany: {
            args: Prisma.unitsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>[]
          }
          delete: {
            args: Prisma.unitsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>
          }
          update: {
            args: Prisma.unitsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>
          }
          deleteMany: {
            args: Prisma.unitsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.unitsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.unitsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unitsPayload>[]
          }
          aggregate: {
            args: Prisma.UnitsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUnits>
          }
          groupBy: {
            args: Prisma.unitsGroupByArgs<ExtArgs>
            result: $Utils.Optional<UnitsGroupByOutputType>[]
          }
          count: {
            args: Prisma.unitsCountArgs<ExtArgs>
            result: $Utils.Optional<UnitsCountAggregateOutputType> | number
          }
        }
      }
      patrol_units: {
        payload: Prisma.$patrol_unitsPayload<ExtArgs>
        fields: Prisma.patrol_unitsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.patrol_unitsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.patrol_unitsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          findFirst: {
            args: Prisma.patrol_unitsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.patrol_unitsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          findMany: {
            args: Prisma.patrol_unitsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>[]
          }
          create: {
            args: Prisma.patrol_unitsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          createMany: {
            args: Prisma.patrol_unitsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.patrol_unitsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>[]
          }
          delete: {
            args: Prisma.patrol_unitsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          update: {
            args: Prisma.patrol_unitsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          deleteMany: {
            args: Prisma.patrol_unitsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.patrol_unitsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.patrol_unitsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>[]
          }
          upsert: {
            args: Prisma.patrol_unitsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$patrol_unitsPayload>
          }
          aggregate: {
            args: Prisma.Patrol_unitsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePatrol_units>
          }
          groupBy: {
            args: Prisma.patrol_unitsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Patrol_unitsGroupByOutputType>[]
          }
          count: {
            args: Prisma.patrol_unitsCountArgs<ExtArgs>
            result: $Utils.Optional<Patrol_unitsCountAggregateOutputType> | number
          }
        }
      }
      officers: {
        payload: Prisma.$officersPayload<ExtArgs>
        fields: Prisma.officersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.officersFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.officersFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          findFirst: {
            args: Prisma.officersFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.officersFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          findMany: {
            args: Prisma.officersFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>[]
          }
          create: {
            args: Prisma.officersCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          createMany: {
            args: Prisma.officersCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.officersCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>[]
          }
          delete: {
            args: Prisma.officersDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          update: {
            args: Prisma.officersUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          deleteMany: {
            args: Prisma.officersDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.officersUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.officersUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>[]
          }
          upsert: {
            args: Prisma.officersUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$officersPayload>
          }
          aggregate: {
            args: Prisma.OfficersAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOfficers>
          }
          groupBy: {
            args: Prisma.officersGroupByArgs<ExtArgs>
            result: $Utils.Optional<OfficersGroupByOutputType>[]
          }
          count: {
            args: Prisma.officersCountArgs<ExtArgs>
            result: $Utils.Optional<OfficersCountAggregateOutputType> | number
          }
        }
      }
      unit_statistics: {
        payload: Prisma.$unit_statisticsPayload<ExtArgs>
        fields: Prisma.unit_statisticsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.unit_statisticsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.unit_statisticsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          findFirst: {
            args: Prisma.unit_statisticsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.unit_statisticsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          findMany: {
            args: Prisma.unit_statisticsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>[]
          }
          create: {
            args: Prisma.unit_statisticsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          createMany: {
            args: Prisma.unit_statisticsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.unit_statisticsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>[]
          }
          delete: {
            args: Prisma.unit_statisticsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          update: {
            args: Prisma.unit_statisticsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          deleteMany: {
            args: Prisma.unit_statisticsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.unit_statisticsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.unit_statisticsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>[]
          }
          upsert: {
            args: Prisma.unit_statisticsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$unit_statisticsPayload>
          }
          aggregate: {
            args: Prisma.Unit_statisticsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUnit_statistics>
          }
          groupBy: {
            args: Prisma.unit_statisticsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Unit_statisticsGroupByOutputType>[]
          }
          count: {
            args: Prisma.unit_statisticsCountArgs<ExtArgs>
            result: $Utils.Optional<Unit_statisticsCountAggregateOutputType> | number
          }
        }
      }
      geographics: {
        payload: Prisma.$geographicsPayload<ExtArgs>
        fields: Prisma.geographicsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.geographicsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.geographicsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>
          }
          findFirst: {
            args: Prisma.geographicsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.geographicsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>
          }
          findMany: {
            args: Prisma.geographicsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>[]
          }
          delete: {
            args: Prisma.geographicsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>
          }
          update: {
            args: Prisma.geographicsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>
          }
          deleteMany: {
            args: Prisma.geographicsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.geographicsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.geographicsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$geographicsPayload>[]
          }
          aggregate: {
            args: Prisma.GeographicsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGeographics>
          }
          groupBy: {
            args: Prisma.geographicsGroupByArgs<ExtArgs>
            result: $Utils.Optional<GeographicsGroupByOutputType>[]
          }
          count: {
            args: Prisma.geographicsCountArgs<ExtArgs>
            result: $Utils.Optional<GeographicsCountAggregateOutputType> | number
          }
        }
      }
      contact_messages: {
        payload: Prisma.$contact_messagesPayload<ExtArgs>
        fields: Prisma.contact_messagesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.contact_messagesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.contact_messagesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          findFirst: {
            args: Prisma.contact_messagesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.contact_messagesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          findMany: {
            args: Prisma.contact_messagesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>[]
          }
          create: {
            args: Prisma.contact_messagesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          createMany: {
            args: Prisma.contact_messagesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.contact_messagesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>[]
          }
          delete: {
            args: Prisma.contact_messagesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          update: {
            args: Prisma.contact_messagesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          deleteMany: {
            args: Prisma.contact_messagesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.contact_messagesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.contact_messagesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>[]
          }
          upsert: {
            args: Prisma.contact_messagesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$contact_messagesPayload>
          }
          aggregate: {
            args: Prisma.Contact_messagesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateContact_messages>
          }
          groupBy: {
            args: Prisma.contact_messagesGroupByArgs<ExtArgs>
            result: $Utils.Optional<Contact_messagesGroupByOutputType>[]
          }
          count: {
            args: Prisma.contact_messagesCountArgs<ExtArgs>
            result: $Utils.Optional<Contact_messagesCountAggregateOutputType> | number
          }
        }
      }
      messages: {
        payload: Prisma.$messagesPayload<ExtArgs>
        fields: Prisma.messagesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.messagesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.messagesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          findFirst: {
            args: Prisma.messagesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.messagesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          findMany: {
            args: Prisma.messagesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>[]
          }
          create: {
            args: Prisma.messagesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          createMany: {
            args: Prisma.messagesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.messagesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>[]
          }
          delete: {
            args: Prisma.messagesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          update: {
            args: Prisma.messagesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          deleteMany: {
            args: Prisma.messagesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.messagesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.messagesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>[]
          }
          upsert: {
            args: Prisma.messagesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$messagesPayload>
          }
          aggregate: {
            args: Prisma.MessagesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMessages>
          }
          groupBy: {
            args: Prisma.messagesGroupByArgs<ExtArgs>
            result: $Utils.Optional<MessagesGroupByOutputType>[]
          }
          count: {
            args: Prisma.messagesCountArgs<ExtArgs>
            result: $Utils.Optional<MessagesCountAggregateOutputType> | number
          }
        }
      }
      inbox: {
        payload: Prisma.$inboxPayload<ExtArgs>
        fields: Prisma.inboxFieldRefs
        operations: {
          findUnique: {
            args: Prisma.inboxFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.inboxFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          findFirst: {
            args: Prisma.inboxFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.inboxFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          findMany: {
            args: Prisma.inboxFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>[]
          }
          create: {
            args: Prisma.inboxCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          createMany: {
            args: Prisma.inboxCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.inboxCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>[]
          }
          delete: {
            args: Prisma.inboxDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          update: {
            args: Prisma.inboxUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          deleteMany: {
            args: Prisma.inboxDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.inboxUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.inboxUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>[]
          }
          upsert: {
            args: Prisma.inboxUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$inboxPayload>
          }
          aggregate: {
            args: Prisma.InboxAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateInbox>
          }
          groupBy: {
            args: Prisma.inboxGroupByArgs<ExtArgs>
            result: $Utils.Optional<InboxGroupByOutputType>[]
          }
          count: {
            args: Prisma.inboxCountArgs<ExtArgs>
            result: $Utils.Optional<InboxCountAggregateOutputType> | number
          }
        }
      }
      logs: {
        payload: Prisma.$logsPayload<ExtArgs>
        fields: Prisma.logsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.logsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.logsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          findFirst: {
            args: Prisma.logsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.logsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          findMany: {
            args: Prisma.logsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>[]
          }
          create: {
            args: Prisma.logsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          createMany: {
            args: Prisma.logsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.logsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>[]
          }
          delete: {
            args: Prisma.logsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          update: {
            args: Prisma.logsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          deleteMany: {
            args: Prisma.logsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.logsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.logsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>[]
          }
          upsert: {
            args: Prisma.logsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$logsPayload>
          }
          aggregate: {
            args: Prisma.LogsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLogs>
          }
          groupBy: {
            args: Prisma.logsGroupByArgs<ExtArgs>
            result: $Utils.Optional<LogsGroupByOutputType>[]
          }
          count: {
            args: Prisma.logsCountArgs<ExtArgs>
            result: $Utils.Optional<LogsCountAggregateOutputType> | number
          }
        }
      }
      panic_button_logs: {
        payload: Prisma.$panic_button_logsPayload<ExtArgs>
        fields: Prisma.panic_button_logsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.panic_button_logsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.panic_button_logsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          findFirst: {
            args: Prisma.panic_button_logsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.panic_button_logsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          findMany: {
            args: Prisma.panic_button_logsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>[]
          }
          create: {
            args: Prisma.panic_button_logsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          createMany: {
            args: Prisma.panic_button_logsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.panic_button_logsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>[]
          }
          delete: {
            args: Prisma.panic_button_logsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          update: {
            args: Prisma.panic_button_logsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          deleteMany: {
            args: Prisma.panic_button_logsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.panic_button_logsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.panic_button_logsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>[]
          }
          upsert: {
            args: Prisma.panic_button_logsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$panic_button_logsPayload>
          }
          aggregate: {
            args: Prisma.Panic_button_logsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePanic_button_logs>
          }
          groupBy: {
            args: Prisma.panic_button_logsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Panic_button_logsGroupByOutputType>[]
          }
          count: {
            args: Prisma.panic_button_logsCountArgs<ExtArgs>
            result: $Utils.Optional<Panic_button_logsCountAggregateOutputType> | number
          }
        }
      }
      location_logs: {
        payload: Prisma.$location_logsPayload<ExtArgs>
        fields: Prisma.location_logsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.location_logsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.location_logsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>
          }
          findFirst: {
            args: Prisma.location_logsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.location_logsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>
          }
          findMany: {
            args: Prisma.location_logsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>[]
          }
          delete: {
            args: Prisma.location_logsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>
          }
          update: {
            args: Prisma.location_logsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>
          }
          deleteMany: {
            args: Prisma.location_logsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.location_logsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.location_logsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$location_logsPayload>[]
          }
          aggregate: {
            args: Prisma.Location_logsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLocation_logs>
          }
          groupBy: {
            args: Prisma.location_logsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Location_logsGroupByOutputType>[]
          }
          count: {
            args: Prisma.location_logsCountArgs<ExtArgs>
            result: $Utils.Optional<Location_logsCountAggregateOutputType> | number
          }
        }
      }
      district_clusters: {
        payload: Prisma.$district_clustersPayload<ExtArgs>
        fields: Prisma.district_clustersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.district_clustersFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.district_clustersFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          findFirst: {
            args: Prisma.district_clustersFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.district_clustersFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          findMany: {
            args: Prisma.district_clustersFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>[]
          }
          create: {
            args: Prisma.district_clustersCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          createMany: {
            args: Prisma.district_clustersCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.district_clustersCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>[]
          }
          delete: {
            args: Prisma.district_clustersDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          update: {
            args: Prisma.district_clustersUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          deleteMany: {
            args: Prisma.district_clustersDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.district_clustersUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.district_clustersUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>[]
          }
          upsert: {
            args: Prisma.district_clustersUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$district_clustersPayload>
          }
          aggregate: {
            args: Prisma.District_clustersAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDistrict_clusters>
          }
          groupBy: {
            args: Prisma.district_clustersGroupByArgs<ExtArgs>
            result: $Utils.Optional<District_clustersGroupByOutputType>[]
          }
          count: {
            args: Prisma.district_clustersCountArgs<ExtArgs>
            result: $Utils.Optional<District_clustersCountAggregateOutputType> | number
          }
        }
      }
      cluster_updates: {
        payload: Prisma.$cluster_updatesPayload<ExtArgs>
        fields: Prisma.cluster_updatesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.cluster_updatesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.cluster_updatesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          findFirst: {
            args: Prisma.cluster_updatesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.cluster_updatesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          findMany: {
            args: Prisma.cluster_updatesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>[]
          }
          create: {
            args: Prisma.cluster_updatesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          createMany: {
            args: Prisma.cluster_updatesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.cluster_updatesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>[]
          }
          delete: {
            args: Prisma.cluster_updatesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          update: {
            args: Prisma.cluster_updatesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          deleteMany: {
            args: Prisma.cluster_updatesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.cluster_updatesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.cluster_updatesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>[]
          }
          upsert: {
            args: Prisma.cluster_updatesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$cluster_updatesPayload>
          }
          aggregate: {
            args: Prisma.Cluster_updatesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCluster_updates>
          }
          groupBy: {
            args: Prisma.cluster_updatesGroupByArgs<ExtArgs>
            result: $Utils.Optional<Cluster_updatesGroupByOutputType>[]
          }
          count: {
            args: Prisma.cluster_updatesCountArgs<ExtArgs>
            result: $Utils.Optional<Cluster_updatesCountAggregateOutputType> | number
          }
        }
      }
      task: {
        payload: Prisma.$taskPayload<ExtArgs>
        fields: Prisma.taskFieldRefs
        operations: {
          findUnique: {
            args: Prisma.taskFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.taskFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          findFirst: {
            args: Prisma.taskFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.taskFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          findMany: {
            args: Prisma.taskFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>[]
          }
          create: {
            args: Prisma.taskCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          createMany: {
            args: Prisma.taskCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.taskCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>[]
          }
          delete: {
            args: Prisma.taskDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          update: {
            args: Prisma.taskUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          deleteMany: {
            args: Prisma.taskDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.taskUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.taskUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>[]
          }
          upsert: {
            args: Prisma.taskUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$taskPayload>
          }
          aggregate: {
            args: Prisma.TaskAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTask>
          }
          groupBy: {
            args: Prisma.taskGroupByArgs<ExtArgs>
            result: $Utils.Optional<TaskGroupByOutputType>[]
          }
          count: {
            args: Prisma.taskCountArgs<ExtArgs>
            result: $Utils.Optional<TaskCountAggregateOutputType> | number
          }
        }
      }
      projects: {
        payload: Prisma.$projectsPayload<ExtArgs>
        fields: Prisma.projectsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.projectsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.projectsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          findFirst: {
            args: Prisma.projectsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.projectsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          findMany: {
            args: Prisma.projectsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>[]
          }
          create: {
            args: Prisma.projectsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          createMany: {
            args: Prisma.projectsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.projectsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>[]
          }
          delete: {
            args: Prisma.projectsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          update: {
            args: Prisma.projectsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          deleteMany: {
            args: Prisma.projectsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.projectsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.projectsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>[]
          }
          upsert: {
            args: Prisma.projectsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$projectsPayload>
          }
          aggregate: {
            args: Prisma.ProjectsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProjects>
          }
          groupBy: {
            args: Prisma.projectsGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProjectsGroupByOutputType>[]
          }
          count: {
            args: Prisma.projectsCountArgs<ExtArgs>
            result: $Utils.Optional<ProjectsCountAggregateOutputType> | number
          }
        }
      }
      datasets: {
        payload: Prisma.$datasetsPayload<ExtArgs>
        fields: Prisma.datasetsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.datasetsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.datasetsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          findFirst: {
            args: Prisma.datasetsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.datasetsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          findMany: {
            args: Prisma.datasetsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>[]
          }
          create: {
            args: Prisma.datasetsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          createMany: {
            args: Prisma.datasetsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.datasetsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>[]
          }
          delete: {
            args: Prisma.datasetsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          update: {
            args: Prisma.datasetsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          deleteMany: {
            args: Prisma.datasetsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.datasetsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.datasetsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>[]
          }
          upsert: {
            args: Prisma.datasetsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$datasetsPayload>
          }
          aggregate: {
            args: Prisma.DatasetsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDatasets>
          }
          groupBy: {
            args: Prisma.datasetsGroupByArgs<ExtArgs>
            result: $Utils.Optional<DatasetsGroupByOutputType>[]
          }
          count: {
            args: Prisma.datasetsCountArgs<ExtArgs>
            result: $Utils.Optional<DatasetsCountAggregateOutputType> | number
          }
        }
      }
      analyses: {
        payload: Prisma.$analysesPayload<ExtArgs>
        fields: Prisma.analysesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.analysesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.analysesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          findFirst: {
            args: Prisma.analysesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.analysesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          findMany: {
            args: Prisma.analysesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>[]
          }
          create: {
            args: Prisma.analysesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          createMany: {
            args: Prisma.analysesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.analysesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>[]
          }
          delete: {
            args: Prisma.analysesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          update: {
            args: Prisma.analysesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          deleteMany: {
            args: Prisma.analysesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.analysesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.analysesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>[]
          }
          upsert: {
            args: Prisma.analysesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysesPayload>
          }
          aggregate: {
            args: Prisma.AnalysesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAnalyses>
          }
          groupBy: {
            args: Prisma.analysesGroupByArgs<ExtArgs>
            result: $Utils.Optional<AnalysesGroupByOutputType>[]
          }
          count: {
            args: Prisma.analysesCountArgs<ExtArgs>
            result: $Utils.Optional<AnalysesCountAggregateOutputType> | number
          }
        }
      }
      clusters: {
        payload: Prisma.$clustersPayload<ExtArgs>
        fields: Prisma.clustersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.clustersFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.clustersFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          findFirst: {
            args: Prisma.clustersFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.clustersFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          findMany: {
            args: Prisma.clustersFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>[]
          }
          create: {
            args: Prisma.clustersCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          createMany: {
            args: Prisma.clustersCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.clustersCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>[]
          }
          delete: {
            args: Prisma.clustersDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          update: {
            args: Prisma.clustersUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          deleteMany: {
            args: Prisma.clustersDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.clustersUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.clustersUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>[]
          }
          upsert: {
            args: Prisma.clustersUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$clustersPayload>
          }
          aggregate: {
            args: Prisma.ClustersAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClusters>
          }
          groupBy: {
            args: Prisma.clustersGroupByArgs<ExtArgs>
            result: $Utils.Optional<ClustersGroupByOutputType>[]
          }
          count: {
            args: Prisma.clustersCountArgs<ExtArgs>
            result: $Utils.Optional<ClustersCountAggregateOutputType> | number
          }
        }
      }
      analysis_templates: {
        payload: Prisma.$analysis_templatesPayload<ExtArgs>
        fields: Prisma.analysis_templatesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.analysis_templatesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.analysis_templatesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          findFirst: {
            args: Prisma.analysis_templatesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.analysis_templatesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          findMany: {
            args: Prisma.analysis_templatesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>[]
          }
          create: {
            args: Prisma.analysis_templatesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          createMany: {
            args: Prisma.analysis_templatesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.analysis_templatesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>[]
          }
          delete: {
            args: Prisma.analysis_templatesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          update: {
            args: Prisma.analysis_templatesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          deleteMany: {
            args: Prisma.analysis_templatesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.analysis_templatesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.analysis_templatesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>[]
          }
          upsert: {
            args: Prisma.analysis_templatesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$analysis_templatesPayload>
          }
          aggregate: {
            args: Prisma.Analysis_templatesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAnalysis_templates>
          }
          groupBy: {
            args: Prisma.analysis_templatesGroupByArgs<ExtArgs>
            result: $Utils.Optional<Analysis_templatesGroupByOutputType>[]
          }
          count: {
            args: Prisma.analysis_templatesCountArgs<ExtArgs>
            result: $Utils.Optional<Analysis_templatesCountAggregateOutputType> | 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
    }
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
  }
  export type GlobalOmitConfig = {
    profiles?: profilesOmit
    users?: usersOmit
    roles?: rolesOmit
    sessions?: sessionsOmit
    events?: eventsOmit
    resources?: resourcesOmit
    permissions?: permissionsOmit
    cities?: citiesOmit
    crime_incidents?: crime_incidentsOmit
    crime_categories?: crime_categoriesOmit
    crimes?: crimesOmit
    demographics?: demographicsOmit
    districts?: districtsOmit
    locations?: locationsOmit
    incident_logs?: incident_logsOmit
    timelines?: timelinesOmit
    witnesses?: witnessesOmit
    evidence?: evidenceOmit
    units?: unitsOmit
    patrol_units?: patrol_unitsOmit
    officers?: officersOmit
    unit_statistics?: unit_statisticsOmit
    geographics?: geographicsOmit
    contact_messages?: contact_messagesOmit
    messages?: messagesOmit
    inbox?: inboxOmit
    logs?: logsOmit
    panic_button_logs?: panic_button_logsOmit
    location_logs?: location_logsOmit
    district_clusters?: district_clustersOmit
    cluster_updates?: cluster_updatesOmit
    task?: taskOmit
    projects?: projectsOmit
    datasets?: datasetsOmit
    analyses?: analysesOmit
    clusters?: clustersOmit
    analysis_templates?: analysis_templatesOmit
  }

  /* 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'
    | 'updateManyAndReturn'
    | '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 UsersCountOutputType
   */

  export type UsersCountOutputType = {
    events: number
    incident_logs: number
    panic_button_logs: number
    sessions: number
    timelines: number
    task: number
    sentMessages: number
    receivedMessages: number
    projects: number
  }

  export type UsersCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    events?: boolean | UsersCountOutputTypeCountEventsArgs
    incident_logs?: boolean | UsersCountOutputTypeCountIncident_logsArgs
    panic_button_logs?: boolean | UsersCountOutputTypeCountPanic_button_logsArgs
    sessions?: boolean | UsersCountOutputTypeCountSessionsArgs
    timelines?: boolean | UsersCountOutputTypeCountTimelinesArgs
    task?: boolean | UsersCountOutputTypeCountTaskArgs
    sentMessages?: boolean | UsersCountOutputTypeCountSentMessagesArgs
    receivedMessages?: boolean | UsersCountOutputTypeCountReceivedMessagesArgs
    projects?: boolean | UsersCountOutputTypeCountProjectsArgs
  }

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

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: eventsWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountIncident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: incident_logsWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountPanic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: panic_button_logsWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: sessionsWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountTimelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: timelinesWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountTaskArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: taskWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountSentMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountReceivedMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
  }

  /**
   * UsersCountOutputType without action
   */
  export type UsersCountOutputTypeCountProjectsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: projectsWhereInput
  }


  /**
   * Count Type RolesCountOutputType
   */

  export type RolesCountOutputType = {
    officers: number
    permissions: number
    users: number
  }

  export type RolesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    officers?: boolean | RolesCountOutputTypeCountOfficersArgs
    permissions?: boolean | RolesCountOutputTypeCountPermissionsArgs
    users?: boolean | RolesCountOutputTypeCountUsersArgs
  }

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

  /**
   * RolesCountOutputType without action
   */
  export type RolesCountOutputTypeCountOfficersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: officersWhereInput
  }

  /**
   * RolesCountOutputType without action
   */
  export type RolesCountOutputTypeCountPermissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: permissionsWhereInput
  }

  /**
   * RolesCountOutputType without action
   */
  export type RolesCountOutputTypeCountUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: usersWhereInput
  }


  /**
   * Count Type EventsCountOutputType
   */

  export type EventsCountOutputType = {
    locations: number
    sessions: number
  }

  export type EventsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    locations?: boolean | EventsCountOutputTypeCountLocationsArgs
    sessions?: boolean | EventsCountOutputTypeCountSessionsArgs
  }

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

  /**
   * EventsCountOutputType without action
   */
  export type EventsCountOutputTypeCountLocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: locationsWhereInput
  }

  /**
   * EventsCountOutputType without action
   */
  export type EventsCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: sessionsWhereInput
  }


  /**
   * Count Type ResourcesCountOutputType
   */

  export type ResourcesCountOutputType = {
    permissions: number
  }

  export type ResourcesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    permissions?: boolean | ResourcesCountOutputTypeCountPermissionsArgs
  }

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

  /**
   * ResourcesCountOutputType without action
   */
  export type ResourcesCountOutputTypeCountPermissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: permissionsWhereInput
  }


  /**
   * Count Type CitiesCountOutputType
   */

  export type CitiesCountOutputType = {
    districts: number
    units: number
  }

  export type CitiesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | CitiesCountOutputTypeCountDistrictsArgs
    units?: boolean | CitiesCountOutputTypeCountUnitsArgs
  }

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

  /**
   * CitiesCountOutputType without action
   */
  export type CitiesCountOutputTypeCountDistrictsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: districtsWhereInput
  }

  /**
   * CitiesCountOutputType without action
   */
  export type CitiesCountOutputTypeCountUnitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: unitsWhereInput
  }


  /**
   * Count Type Crime_incidentsCountOutputType
   */

  export type Crime_incidentsCountOutputType = {
    evidences: number
    timelines: number
    witnesses: number
  }

  export type Crime_incidentsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    evidences?: boolean | Crime_incidentsCountOutputTypeCountEvidencesArgs
    timelines?: boolean | Crime_incidentsCountOutputTypeCountTimelinesArgs
    witnesses?: boolean | Crime_incidentsCountOutputTypeCountWitnessesArgs
  }

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

  /**
   * Crime_incidentsCountOutputType without action
   */
  export type Crime_incidentsCountOutputTypeCountEvidencesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: evidenceWhereInput
  }

  /**
   * Crime_incidentsCountOutputType without action
   */
  export type Crime_incidentsCountOutputTypeCountTimelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: timelinesWhereInput
  }

  /**
   * Crime_incidentsCountOutputType without action
   */
  export type Crime_incidentsCountOutputTypeCountWitnessesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: witnessesWhereInput
  }


  /**
   * Count Type Crime_categoriesCountOutputType
   */

  export type Crime_categoriesCountOutputType = {
    crime_incidents: number
    incident_logs: number
  }

  export type Crime_categoriesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | Crime_categoriesCountOutputTypeCountCrime_incidentsArgs
    incident_logs?: boolean | Crime_categoriesCountOutputTypeCountIncident_logsArgs
  }

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

  /**
   * Crime_categoriesCountOutputType without action
   */
  export type Crime_categoriesCountOutputTypeCountCrime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crime_incidentsWhereInput
  }

  /**
   * Crime_categoriesCountOutputType without action
   */
  export type Crime_categoriesCountOutputTypeCountIncident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: incident_logsWhereInput
  }


  /**
   * Count Type CrimesCountOutputType
   */

  export type CrimesCountOutputType = {
    crime_incidents: number
  }

  export type CrimesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | CrimesCountOutputTypeCountCrime_incidentsArgs
  }

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

  /**
   * CrimesCountOutputType without action
   */
  export type CrimesCountOutputTypeCountCrime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crime_incidentsWhereInput
  }


  /**
   * Count Type DistrictsCountOutputType
   */

  export type DistrictsCountOutputType = {
    crimes: number
    demographics: number
    district_clusters: number
    geographics: number
    locations: number
  }

  export type DistrictsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crimes?: boolean | DistrictsCountOutputTypeCountCrimesArgs
    demographics?: boolean | DistrictsCountOutputTypeCountDemographicsArgs
    district_clusters?: boolean | DistrictsCountOutputTypeCountDistrict_clustersArgs
    geographics?: boolean | DistrictsCountOutputTypeCountGeographicsArgs
    locations?: boolean | DistrictsCountOutputTypeCountLocationsArgs
  }

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

  /**
   * DistrictsCountOutputType without action
   */
  export type DistrictsCountOutputTypeCountCrimesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crimesWhereInput
  }

  /**
   * DistrictsCountOutputType without action
   */
  export type DistrictsCountOutputTypeCountDemographicsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: demographicsWhereInput
  }

  /**
   * DistrictsCountOutputType without action
   */
  export type DistrictsCountOutputTypeCountDistrict_clustersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: district_clustersWhereInput
  }

  /**
   * DistrictsCountOutputType without action
   */
  export type DistrictsCountOutputTypeCountGeographicsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: geographicsWhereInput
  }

  /**
   * DistrictsCountOutputType without action
   */
  export type DistrictsCountOutputTypeCountLocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: locationsWhereInput
  }


  /**
   * Count Type LocationsCountOutputType
   */

  export type LocationsCountOutputType = {
    crime_incidents: number
    incident_logs: number
    location_logs: number
    patrol_units: number
  }

  export type LocationsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | LocationsCountOutputTypeCountCrime_incidentsArgs
    incident_logs?: boolean | LocationsCountOutputTypeCountIncident_logsArgs
    location_logs?: boolean | LocationsCountOutputTypeCountLocation_logsArgs
    patrol_units?: boolean | LocationsCountOutputTypeCountPatrol_unitsArgs
  }

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

  /**
   * LocationsCountOutputType without action
   */
  export type LocationsCountOutputTypeCountCrime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crime_incidentsWhereInput
  }

  /**
   * LocationsCountOutputType without action
   */
  export type LocationsCountOutputTypeCountIncident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: incident_logsWhereInput
  }

  /**
   * LocationsCountOutputType without action
   */
  export type LocationsCountOutputTypeCountLocation_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: location_logsWhereInput
  }

  /**
   * LocationsCountOutputType without action
   */
  export type LocationsCountOutputTypeCountPatrol_unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: patrol_unitsWhereInput
  }


  /**
   * Count Type Incident_logsCountOutputType
   */

  export type Incident_logsCountOutputType = {
    evidence: number
    panic_button_logs: number
    timelines: number
    witnesses: number
  }

  export type Incident_logsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    evidence?: boolean | Incident_logsCountOutputTypeCountEvidenceArgs
    panic_button_logs?: boolean | Incident_logsCountOutputTypeCountPanic_button_logsArgs
    timelines?: boolean | Incident_logsCountOutputTypeCountTimelinesArgs
    witnesses?: boolean | Incident_logsCountOutputTypeCountWitnessesArgs
  }

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

  /**
   * Incident_logsCountOutputType without action
   */
  export type Incident_logsCountOutputTypeCountEvidenceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: evidenceWhereInput
  }

  /**
   * Incident_logsCountOutputType without action
   */
  export type Incident_logsCountOutputTypeCountPanic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: panic_button_logsWhereInput
  }

  /**
   * Incident_logsCountOutputType without action
   */
  export type Incident_logsCountOutputTypeCountTimelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: timelinesWhereInput
  }

  /**
   * Incident_logsCountOutputType without action
   */
  export type Incident_logsCountOutputTypeCountWitnessesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: witnessesWhereInput
  }


  /**
   * Count Type UnitsCountOutputType
   */

  export type UnitsCountOutputType = {
    officers: number
    patrol_units: number
    unit_statistics: number
  }

  export type UnitsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    officers?: boolean | UnitsCountOutputTypeCountOfficersArgs
    patrol_units?: boolean | UnitsCountOutputTypeCountPatrol_unitsArgs
    unit_statistics?: boolean | UnitsCountOutputTypeCountUnit_statisticsArgs
  }

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

  /**
   * UnitsCountOutputType without action
   */
  export type UnitsCountOutputTypeCountOfficersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: officersWhereInput
  }

  /**
   * UnitsCountOutputType without action
   */
  export type UnitsCountOutputTypeCountPatrol_unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: patrol_unitsWhereInput
  }

  /**
   * UnitsCountOutputType without action
   */
  export type UnitsCountOutputTypeCountUnit_statisticsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: unit_statisticsWhereInput
  }


  /**
   * Count Type Patrol_unitsCountOutputType
   */

  export type Patrol_unitsCountOutputType = {
    members: number
  }

  export type Patrol_unitsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    members?: boolean | Patrol_unitsCountOutputTypeCountMembersArgs
  }

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

  /**
   * Patrol_unitsCountOutputType without action
   */
  export type Patrol_unitsCountOutputTypeCountMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: officersWhereInput
  }


  /**
   * Count Type OfficersCountOutputType
   */

  export type OfficersCountOutputType = {
    panic_button_logs: number
    sentMessages: number
    receivedMessages: number
  }

  export type OfficersCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    panic_button_logs?: boolean | OfficersCountOutputTypeCountPanic_button_logsArgs
    sentMessages?: boolean | OfficersCountOutputTypeCountSentMessagesArgs
    receivedMessages?: boolean | OfficersCountOutputTypeCountReceivedMessagesArgs
  }

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

  /**
   * OfficersCountOutputType without action
   */
  export type OfficersCountOutputTypeCountPanic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: panic_button_logsWhereInput
  }

  /**
   * OfficersCountOutputType without action
   */
  export type OfficersCountOutputTypeCountSentMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
  }

  /**
   * OfficersCountOutputType without action
   */
  export type OfficersCountOutputTypeCountReceivedMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
  }


  /**
   * Count Type InboxCountOutputType
   */

  export type InboxCountOutputType = {
    messages: number
  }

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

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

  /**
   * InboxCountOutputType without action
   */
  export type InboxCountOutputTypeCountMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
  }


  /**
   * Count Type ProjectsCountOutputType
   */

  export type ProjectsCountOutputType = {
    datasets: number
    analyses: number
  }

  export type ProjectsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    datasets?: boolean | ProjectsCountOutputTypeCountDatasetsArgs
    analyses?: boolean | ProjectsCountOutputTypeCountAnalysesArgs
  }

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

  /**
   * ProjectsCountOutputType without action
   */
  export type ProjectsCountOutputTypeCountDatasetsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: datasetsWhereInput
  }

  /**
   * ProjectsCountOutputType without action
   */
  export type ProjectsCountOutputTypeCountAnalysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: analysesWhereInput
  }


  /**
   * Count Type DatasetsCountOutputType
   */

  export type DatasetsCountOutputType = {
    analyses: number
  }

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

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

  /**
   * DatasetsCountOutputType without action
   */
  export type DatasetsCountOutputTypeCountAnalysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: analysesWhereInput
  }


  /**
   * Count Type AnalysesCountOutputType
   */

  export type AnalysesCountOutputType = {
    clusters: number
  }

  export type AnalysesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    clusters?: boolean | AnalysesCountOutputTypeCountClustersArgs
  }

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

  /**
   * AnalysesCountOutputType without action
   */
  export type AnalysesCountOutputTypeCountClustersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: clustersWhereInput
  }


  /**
   * Models
   */

  /**
   * Model profiles
   */

  export type AggregateProfiles = {
    _count: ProfilesCountAggregateOutputType | null
    _min: ProfilesMinAggregateOutputType | null
    _max: ProfilesMaxAggregateOutputType | null
  }

  export type ProfilesMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    avatar: string | null
    username: string | null
    first_name: string | null
    last_name: string | null
    bio: string | null
    birth_date: Date | null
    nik: string | null
    birth_place: string | null
  }

  export type ProfilesMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    avatar: string | null
    username: string | null
    first_name: string | null
    last_name: string | null
    bio: string | null
    birth_date: Date | null
    nik: string | null
    birth_place: string | null
  }

  export type ProfilesCountAggregateOutputType = {
    id: number
    user_id: number
    avatar: number
    username: number
    first_name: number
    last_name: number
    bio: number
    address: number
    birth_date: number
    nik: number
    birth_place: number
    _all: number
  }


  export type ProfilesMinAggregateInputType = {
    id?: true
    user_id?: true
    avatar?: true
    username?: true
    first_name?: true
    last_name?: true
    bio?: true
    birth_date?: true
    nik?: true
    birth_place?: true
  }

  export type ProfilesMaxAggregateInputType = {
    id?: true
    user_id?: true
    avatar?: true
    username?: true
    first_name?: true
    last_name?: true
    bio?: true
    birth_date?: true
    nik?: true
    birth_place?: true
  }

  export type ProfilesCountAggregateInputType = {
    id?: true
    user_id?: true
    avatar?: true
    username?: true
    first_name?: true
    last_name?: true
    bio?: true
    address?: true
    birth_date?: true
    nik?: true
    birth_place?: true
    _all?: true
  }

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

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




  export type profilesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: profilesWhereInput
    orderBy?: profilesOrderByWithAggregationInput | profilesOrderByWithAggregationInput[]
    by: ProfilesScalarFieldEnum[] | ProfilesScalarFieldEnum
    having?: profilesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProfilesCountAggregateInputType | true
    _min?: ProfilesMinAggregateInputType
    _max?: ProfilesMaxAggregateInputType
  }

  export type ProfilesGroupByOutputType = {
    id: string
    user_id: string
    avatar: string | null
    username: string | null
    first_name: string | null
    last_name: string | null
    bio: string | null
    address: JsonValue | null
    birth_date: Date | null
    nik: string | null
    birth_place: string | null
    _count: ProfilesCountAggregateOutputType | null
    _min: ProfilesMinAggregateOutputType | null
    _max: ProfilesMaxAggregateOutputType | null
  }

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


  export type profilesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    avatar?: boolean
    username?: boolean
    first_name?: boolean
    last_name?: boolean
    bio?: boolean
    address?: boolean
    birth_date?: boolean
    nik?: boolean
    birth_place?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["profiles"]>

  export type profilesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    avatar?: boolean
    username?: boolean
    first_name?: boolean
    last_name?: boolean
    bio?: boolean
    address?: boolean
    birth_date?: boolean
    nik?: boolean
    birth_place?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["profiles"]>

  export type profilesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    avatar?: boolean
    username?: boolean
    first_name?: boolean
    last_name?: boolean
    bio?: boolean
    address?: boolean
    birth_date?: boolean
    nik?: boolean
    birth_place?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["profiles"]>

  export type profilesSelectScalar = {
    id?: boolean
    user_id?: boolean
    avatar?: boolean
    username?: boolean
    first_name?: boolean
    last_name?: boolean
    bio?: boolean
    address?: boolean
    birth_date?: boolean
    nik?: boolean
    birth_place?: boolean
  }

  export type profilesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "avatar" | "username" | "first_name" | "last_name" | "bio" | "address" | "birth_date" | "nik" | "birth_place", ExtArgs["result"]["profiles"]>
  export type profilesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type profilesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type profilesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $profilesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "profiles"
    objects: {
      users: Prisma.$usersPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      avatar: string | null
      username: string | null
      first_name: string | null
      last_name: string | null
      bio: string | null
      address: Prisma.JsonValue | null
      birth_date: Date | null
      nik: string | null
      birth_place: string | null
    }, ExtArgs["result"]["profiles"]>
    composites: {}
  }

  type profilesGetPayload<S extends boolean | null | undefined | profilesDefaultArgs> = $Result.GetResult<Prisma.$profilesPayload, S>

  type profilesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<profilesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: ProfilesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Profiles.
     * @param {profilesCreateArgs} args - Arguments to create a Profiles.
     * @example
     * // Create one Profiles
     * const Profiles = await prisma.profiles.create({
     *   data: {
     *     // ... data to create a Profiles
     *   }
     * })
     * 
     */
    create<T extends profilesCreateArgs>(args: SelectSubset<T, profilesCreateArgs<ExtArgs>>): Prisma__profilesClient<$Result.GetResult<Prisma.$profilesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Profiles.
     * @param {profilesDeleteArgs} args - Arguments to delete one Profiles.
     * @example
     * // Delete one Profiles
     * const Profiles = await prisma.profiles.delete({
     *   where: {
     *     // ... filter to delete one Profiles
     *   }
     * })
     * 
     */
    delete<T extends profilesDeleteArgs>(args: SelectSubset<T, profilesDeleteArgs<ExtArgs>>): Prisma__profilesClient<$Result.GetResult<Prisma.$profilesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the profiles model
   */
  interface profilesFieldRefs {
    readonly id: FieldRef<"profiles", 'String'>
    readonly user_id: FieldRef<"profiles", 'String'>
    readonly avatar: FieldRef<"profiles", 'String'>
    readonly username: FieldRef<"profiles", 'String'>
    readonly first_name: FieldRef<"profiles", 'String'>
    readonly last_name: FieldRef<"profiles", 'String'>
    readonly bio: FieldRef<"profiles", 'String'>
    readonly address: FieldRef<"profiles", 'Json'>
    readonly birth_date: FieldRef<"profiles", 'DateTime'>
    readonly nik: FieldRef<"profiles", 'String'>
    readonly birth_place: FieldRef<"profiles", 'String'>
  }
    

  // Custom InputTypes
  /**
   * profiles findUnique
   */
  export type profilesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * Filter, which profiles to fetch.
     */
    where: profilesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * profiles findUniqueOrThrow
   */
  export type profilesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * Filter, which profiles to fetch.
     */
    where: profilesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * profiles findMany
   */
  export type profilesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * Filter, which profiles to fetch.
     */
    where?: profilesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of profiles to fetch.
     */
    orderBy?: profilesOrderByWithRelationInput | profilesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing profiles.
     */
    cursor?: profilesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` profiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` profiles.
     */
    skip?: number
    distinct?: ProfilesScalarFieldEnum | ProfilesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * profiles create
   */
  export type profilesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * The data needed to create a profiles.
     */
    data: XOR<profilesCreateInput, profilesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * profiles update
   */
  export type profilesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * The data needed to update a profiles.
     */
    data: XOR<profilesUpdateInput, profilesUncheckedUpdateInput>
    /**
     * Choose, which profiles to update.
     */
    where: profilesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * profiles updateMany
   */
  export type profilesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update profiles.
     */
    data: XOR<profilesUpdateManyMutationInput, profilesUncheckedUpdateManyInput>
    /**
     * Filter which profiles to update
     */
    where?: profilesWhereInput
    /**
     * Limit how many profiles to update.
     */
    limit?: number
  }

  /**
   * profiles updateManyAndReturn
   */
  export type profilesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * The data used to update profiles.
     */
    data: XOR<profilesUpdateManyMutationInput, profilesUncheckedUpdateManyInput>
    /**
     * Filter which profiles to update
     */
    where?: profilesWhereInput
    /**
     * Limit how many profiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * profiles upsert
   */
  export type profilesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * The filter to search for the profiles to update in case it exists.
     */
    where: profilesWhereUniqueInput
    /**
     * In case the profiles found by the `where` argument doesn't exist, create a new profiles with this data.
     */
    create: XOR<profilesCreateInput, profilesUncheckedCreateInput>
    /**
     * In case the profiles was found with the provided `where` argument, update it with this data.
     */
    update: XOR<profilesUpdateInput, profilesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * profiles delete
   */
  export type profilesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    /**
     * Filter which profiles to delete.
     */
    where: profilesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model users
   */

  export type AggregateUsers = {
    _count: UsersCountAggregateOutputType | null
    _avg: UsersAvgAggregateOutputType | null
    _sum: UsersSumAggregateOutputType | null
    _min: UsersMinAggregateOutputType | null
    _max: UsersMaxAggregateOutputType | null
  }

  export type UsersAvgAggregateOutputType = {
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type UsersSumAggregateOutputType = {
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type UsersMinAggregateOutputType = {
    id: string | null
    roles_id: string | null
    email: string | null
    phone: string | null
    encrypted_password: string | null
    invited_at: Date | null
    confirmed_at: Date | null
    email_confirmed_at: Date | null
    recovery_sent_at: Date | null
    last_sign_in_at: Date | null
    created_at: Date | null
    updated_at: Date | null
    banned_until: Date | null
    is_anonymous: boolean | null
    banned_reason: string | null
    is_banned: boolean | null
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type UsersMaxAggregateOutputType = {
    id: string | null
    roles_id: string | null
    email: string | null
    phone: string | null
    encrypted_password: string | null
    invited_at: Date | null
    confirmed_at: Date | null
    email_confirmed_at: Date | null
    recovery_sent_at: Date | null
    last_sign_in_at: Date | null
    created_at: Date | null
    updated_at: Date | null
    banned_until: Date | null
    is_anonymous: boolean | null
    banned_reason: string | null
    is_banned: boolean | null
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type UsersCountAggregateOutputType = {
    id: number
    roles_id: number
    email: number
    phone: number
    encrypted_password: number
    invited_at: number
    confirmed_at: number
    email_confirmed_at: number
    recovery_sent_at: number
    last_sign_in_at: number
    app_metadata: number
    user_metadata: number
    created_at: number
    updated_at: number
    banned_until: number
    is_anonymous: number
    banned_reason: number
    is_banned: number
    panic_strike: number
    spoofing_attempts: number
    _all: number
  }


  export type UsersAvgAggregateInputType = {
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type UsersSumAggregateInputType = {
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type UsersMinAggregateInputType = {
    id?: true
    roles_id?: true
    email?: true
    phone?: true
    encrypted_password?: true
    invited_at?: true
    confirmed_at?: true
    email_confirmed_at?: true
    recovery_sent_at?: true
    last_sign_in_at?: true
    created_at?: true
    updated_at?: true
    banned_until?: true
    is_anonymous?: true
    banned_reason?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type UsersMaxAggregateInputType = {
    id?: true
    roles_id?: true
    email?: true
    phone?: true
    encrypted_password?: true
    invited_at?: true
    confirmed_at?: true
    email_confirmed_at?: true
    recovery_sent_at?: true
    last_sign_in_at?: true
    created_at?: true
    updated_at?: true
    banned_until?: true
    is_anonymous?: true
    banned_reason?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type UsersCountAggregateInputType = {
    id?: true
    roles_id?: true
    email?: true
    phone?: true
    encrypted_password?: true
    invited_at?: true
    confirmed_at?: true
    email_confirmed_at?: true
    recovery_sent_at?: true
    last_sign_in_at?: true
    app_metadata?: true
    user_metadata?: true
    created_at?: true
    updated_at?: true
    banned_until?: true
    is_anonymous?: true
    banned_reason?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
    _all?: true
  }

  export type UsersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which users to aggregate.
     */
    where?: usersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of users to fetch.
     */
    orderBy?: usersOrderByWithRelationInput | usersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: usersWhereUniqueInput
    /**
     * {@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 | UsersCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UsersAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UsersSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UsersMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UsersMaxAggregateInputType
  }

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




  export type usersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: usersWhereInput
    orderBy?: usersOrderByWithAggregationInput | usersOrderByWithAggregationInput[]
    by: UsersScalarFieldEnum[] | UsersScalarFieldEnum
    having?: usersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UsersCountAggregateInputType | true
    _avg?: UsersAvgAggregateInputType
    _sum?: UsersSumAggregateInputType
    _min?: UsersMinAggregateInputType
    _max?: UsersMaxAggregateInputType
  }

  export type UsersGroupByOutputType = {
    id: string
    roles_id: string
    email: string
    phone: string | null
    encrypted_password: string | null
    invited_at: Date | null
    confirmed_at: Date | null
    email_confirmed_at: Date | null
    recovery_sent_at: Date | null
    last_sign_in_at: Date | null
    app_metadata: JsonValue | null
    user_metadata: JsonValue | null
    created_at: Date
    updated_at: Date
    banned_until: Date | null
    is_anonymous: boolean
    banned_reason: string | null
    is_banned: boolean
    panic_strike: number
    spoofing_attempts: number
    _count: UsersCountAggregateOutputType | null
    _avg: UsersAvgAggregateOutputType | null
    _sum: UsersSumAggregateOutputType | null
    _min: UsersMinAggregateOutputType | null
    _max: UsersMaxAggregateOutputType | null
  }

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


  export type usersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    roles_id?: boolean
    email?: boolean
    phone?: boolean
    encrypted_password?: boolean
    invited_at?: boolean
    confirmed_at?: boolean
    email_confirmed_at?: boolean
    recovery_sent_at?: boolean
    last_sign_in_at?: boolean
    app_metadata?: boolean
    user_metadata?: boolean
    created_at?: boolean
    updated_at?: boolean
    banned_until?: boolean
    is_anonymous?: boolean
    banned_reason?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    events?: boolean | users$eventsArgs<ExtArgs>
    incident_logs?: boolean | users$incident_logsArgs<ExtArgs>
    panic_button_logs?: boolean | users$panic_button_logsArgs<ExtArgs>
    profile?: boolean | users$profileArgs<ExtArgs>
    sessions?: boolean | users$sessionsArgs<ExtArgs>
    timelines?: boolean | users$timelinesArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
    task?: boolean | users$taskArgs<ExtArgs>
    sentMessages?: boolean | users$sentMessagesArgs<ExtArgs>
    receivedMessages?: boolean | users$receivedMessagesArgs<ExtArgs>
    projects?: boolean | users$projectsArgs<ExtArgs>
    inbox?: boolean | users$inboxArgs<ExtArgs>
    _count?: boolean | UsersCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["users"]>

  export type usersSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    roles_id?: boolean
    email?: boolean
    phone?: boolean
    encrypted_password?: boolean
    invited_at?: boolean
    confirmed_at?: boolean
    email_confirmed_at?: boolean
    recovery_sent_at?: boolean
    last_sign_in_at?: boolean
    app_metadata?: boolean
    user_metadata?: boolean
    created_at?: boolean
    updated_at?: boolean
    banned_until?: boolean
    is_anonymous?: boolean
    banned_reason?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["users"]>

  export type usersSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    roles_id?: boolean
    email?: boolean
    phone?: boolean
    encrypted_password?: boolean
    invited_at?: boolean
    confirmed_at?: boolean
    email_confirmed_at?: boolean
    recovery_sent_at?: boolean
    last_sign_in_at?: boolean
    app_metadata?: boolean
    user_metadata?: boolean
    created_at?: boolean
    updated_at?: boolean
    banned_until?: boolean
    is_anonymous?: boolean
    banned_reason?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["users"]>

  export type usersSelectScalar = {
    id?: boolean
    roles_id?: boolean
    email?: boolean
    phone?: boolean
    encrypted_password?: boolean
    invited_at?: boolean
    confirmed_at?: boolean
    email_confirmed_at?: boolean
    recovery_sent_at?: boolean
    last_sign_in_at?: boolean
    app_metadata?: boolean
    user_metadata?: boolean
    created_at?: boolean
    updated_at?: boolean
    banned_until?: boolean
    is_anonymous?: boolean
    banned_reason?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
  }

  export type usersOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "roles_id" | "email" | "phone" | "encrypted_password" | "invited_at" | "confirmed_at" | "email_confirmed_at" | "recovery_sent_at" | "last_sign_in_at" | "app_metadata" | "user_metadata" | "created_at" | "updated_at" | "banned_until" | "is_anonymous" | "banned_reason" | "is_banned" | "panic_strike" | "spoofing_attempts", ExtArgs["result"]["users"]>
  export type usersInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    events?: boolean | users$eventsArgs<ExtArgs>
    incident_logs?: boolean | users$incident_logsArgs<ExtArgs>
    panic_button_logs?: boolean | users$panic_button_logsArgs<ExtArgs>
    profile?: boolean | users$profileArgs<ExtArgs>
    sessions?: boolean | users$sessionsArgs<ExtArgs>
    timelines?: boolean | users$timelinesArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
    task?: boolean | users$taskArgs<ExtArgs>
    sentMessages?: boolean | users$sentMessagesArgs<ExtArgs>
    receivedMessages?: boolean | users$receivedMessagesArgs<ExtArgs>
    projects?: boolean | users$projectsArgs<ExtArgs>
    inbox?: boolean | users$inboxArgs<ExtArgs>
    _count?: boolean | UsersCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type usersIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }
  export type usersIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }

  export type $usersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "users"
    objects: {
      events: Prisma.$eventsPayload<ExtArgs>[]
      incident_logs: Prisma.$incident_logsPayload<ExtArgs>[]
      panic_button_logs: Prisma.$panic_button_logsPayload<ExtArgs>[]
      profile: Prisma.$profilesPayload<ExtArgs> | null
      sessions: Prisma.$sessionsPayload<ExtArgs>[]
      timelines: Prisma.$timelinesPayload<ExtArgs>[]
      role: Prisma.$rolesPayload<ExtArgs>
      task: Prisma.$taskPayload<ExtArgs>[]
      sentMessages: Prisma.$messagesPayload<ExtArgs>[]
      receivedMessages: Prisma.$messagesPayload<ExtArgs>[]
      projects: Prisma.$projectsPayload<ExtArgs>[]
      inbox: Prisma.$inboxPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      roles_id: string
      email: string
      phone: string | null
      encrypted_password: string | null
      invited_at: Date | null
      confirmed_at: Date | null
      email_confirmed_at: Date | null
      recovery_sent_at: Date | null
      last_sign_in_at: Date | null
      app_metadata: Prisma.JsonValue | null
      user_metadata: Prisma.JsonValue | null
      created_at: Date
      updated_at: Date
      banned_until: Date | null
      is_anonymous: boolean
      banned_reason: string | null
      is_banned: boolean
      panic_strike: number
      spoofing_attempts: number
    }, ExtArgs["result"]["users"]>
    composites: {}
  }

  type usersGetPayload<S extends boolean | null | undefined | usersDefaultArgs> = $Result.GetResult<Prisma.$usersPayload, S>

  type usersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<usersFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: UsersCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Users.
     * @param {usersCreateArgs} args - Arguments to create a Users.
     * @example
     * // Create one Users
     * const Users = await prisma.users.create({
     *   data: {
     *     // ... data to create a Users
     *   }
     * })
     * 
     */
    create<T extends usersCreateArgs>(args: SelectSubset<T, usersCreateArgs<ExtArgs>>): Prisma__usersClient<$Result.GetResult<Prisma.$usersPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Users.
     * @param {usersDeleteArgs} args - Arguments to delete one Users.
     * @example
     * // Delete one Users
     * const Users = await prisma.users.delete({
     *   where: {
     *     // ... filter to delete one Users
     *   }
     * })
     * 
     */
    delete<T extends usersDeleteArgs>(args: SelectSubset<T, usersDeleteArgs<ExtArgs>>): Prisma__usersClient<$Result.GetResult<Prisma.$usersPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete zero or more Users.
     * @param {usersDeleteManyArgs} args - Arguments to filter Users to delete.
     * @example
     * // Delete a few Users
     * const { count } = await prisma.users.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends usersDeleteManyArgs>(args?: SelectSubset<T, usersDeleteManyArgs<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 {usersUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Users
     * const users = await prisma.users.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends usersUpdateManyArgs>(args: SelectSubset<T, usersUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for users.
   * 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__usersClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    events<T extends users$eventsArgs<ExtArgs> = {}>(args?: Subset<T, users$eventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$eventsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    incident_logs<T extends users$incident_logsArgs<ExtArgs> = {}>(args?: Subset<T, users$incident_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$incident_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    panic_button_logs<T extends users$panic_button_logsArgs<ExtArgs> = {}>(args?: Subset<T, users$panic_button_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$panic_button_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    profile<T extends users$profileArgs<ExtArgs> = {}>(args?: Subset<T, users$profileArgs<ExtArgs>>): Prisma__profilesClient<$Result.GetResult<Prisma.$profilesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    sessions<T extends users$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, users$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$sessionsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    timelines<T extends users$timelinesArgs<ExtArgs> = {}>(args?: Subset<T, users$timelinesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$timelinesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    role<T extends rolesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, rolesDefaultArgs<ExtArgs>>): Prisma__rolesClient<$Result.GetResult<Prisma.$rolesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    task<T extends users$taskArgs<ExtArgs> = {}>(args?: Subset<T, users$taskArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    sentMessages<T extends users$sentMessagesArgs<ExtArgs> = {}>(args?: Subset<T, users$sentMessagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    receivedMessages<T extends users$receivedMessagesArgs<ExtArgs> = {}>(args?: Subset<T, users$receivedMessagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    projects<T extends users$projectsArgs<ExtArgs> = {}>(args?: Subset<T, users$projectsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    inbox<T extends users$inboxArgs<ExtArgs> = {}>(args?: Subset<T, users$inboxArgs<ExtArgs>>): Prisma__inboxClient<$Result.GetResult<Prisma.$inboxPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the users model
   */
  interface usersFieldRefs {
    readonly id: FieldRef<"users", 'String'>
    readonly roles_id: FieldRef<"users", 'String'>
    readonly email: FieldRef<"users", 'String'>
    readonly phone: FieldRef<"users", 'String'>
    readonly encrypted_password: FieldRef<"users", 'String'>
    readonly invited_at: FieldRef<"users", 'DateTime'>
    readonly confirmed_at: FieldRef<"users", 'DateTime'>
    readonly email_confirmed_at: FieldRef<"users", 'DateTime'>
    readonly recovery_sent_at: FieldRef<"users", 'DateTime'>
    readonly last_sign_in_at: FieldRef<"users", 'DateTime'>
    readonly app_metadata: FieldRef<"users", 'Json'>
    readonly user_metadata: FieldRef<"users", 'Json'>
    readonly created_at: FieldRef<"users", 'DateTime'>
    readonly updated_at: FieldRef<"users", 'DateTime'>
    readonly banned_until: FieldRef<"users", 'DateTime'>
    readonly is_anonymous: FieldRef<"users", 'Boolean'>
    readonly banned_reason: FieldRef<"users", 'String'>
    readonly is_banned: FieldRef<"users", 'Boolean'>
    readonly panic_strike: FieldRef<"users", 'Int'>
    readonly spoofing_attempts: FieldRef<"users", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * users findUnique
   */
  export type usersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter, which users to fetch.
     */
    where: usersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users findUniqueOrThrow
   */
  export type usersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter, which users to fetch.
     */
    where: usersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users findFirst
   */
  export type usersFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter, which users to fetch.
     */
    where?: usersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of users to fetch.
     */
    orderBy?: usersOrderByWithRelationInput | usersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for users.
     */
    cursor?: usersWhereUniqueInput
    /**
     * {@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?: UsersScalarFieldEnum | UsersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users findFirstOrThrow
   */
  export type usersFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter, which users to fetch.
     */
    where?: usersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of users to fetch.
     */
    orderBy?: usersOrderByWithRelationInput | usersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for users.
     */
    cursor?: usersWhereUniqueInput
    /**
     * {@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?: UsersScalarFieldEnum | UsersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users findMany
   */
  export type usersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter, which users to fetch.
     */
    where?: usersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of users to fetch.
     */
    orderBy?: usersOrderByWithRelationInput | usersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing users.
     */
    cursor?: usersWhereUniqueInput
    /**
     * {@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?: UsersScalarFieldEnum | UsersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users create
   */
  export type usersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * The data needed to create a users.
     */
    data: XOR<usersCreateInput, usersUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * users update
   */
  export type usersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * The data needed to update a users.
     */
    data: XOR<usersUpdateInput, usersUncheckedUpdateInput>
    /**
     * Choose, which users to update.
     */
    where: usersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users updateMany
   */
  export type usersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update users.
     */
    data: XOR<usersUpdateManyMutationInput, usersUncheckedUpdateManyInput>
    /**
     * Filter which users to update
     */
    where?: usersWhereInput
    /**
     * Limit how many users to update.
     */
    limit?: number
  }

  /**
   * users updateManyAndReturn
   */
  export type usersUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * The data used to update users.
     */
    data: XOR<usersUpdateManyMutationInput, usersUncheckedUpdateManyInput>
    /**
     * Filter which users to update
     */
    where?: usersWhereInput
    /**
     * Limit how many users to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * users upsert
   */
  export type usersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * The filter to search for the users to update in case it exists.
     */
    where: usersWhereUniqueInput
    /**
     * In case the users found by the `where` argument doesn't exist, create a new users with this data.
     */
    create: XOR<usersCreateInput, usersUncheckedCreateInput>
    /**
     * In case the users was found with the provided `where` argument, update it with this data.
     */
    update: XOR<usersUpdateInput, usersUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * users delete
   */
  export type usersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    /**
     * Filter which users to delete.
     */
    where: usersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * users.events
   */
  export type users$eventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    where?: eventsWhereInput
    orderBy?: eventsOrderByWithRelationInput | eventsOrderByWithRelationInput[]
    cursor?: eventsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventsScalarFieldEnum | EventsScalarFieldEnum[]
  }

  /**
   * users.incident_logs
   */
  export type users$incident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
    orderBy?: incident_logsOrderByWithRelationInput | incident_logsOrderByWithRelationInput[]
    cursor?: incident_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Incident_logsScalarFieldEnum | Incident_logsScalarFieldEnum[]
  }

  /**
   * users.panic_button_logs
   */
  export type users$panic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    where?: panic_button_logsWhereInput
    orderBy?: panic_button_logsOrderByWithRelationInput | panic_button_logsOrderByWithRelationInput[]
    cursor?: panic_button_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Panic_button_logsScalarFieldEnum | Panic_button_logsScalarFieldEnum[]
  }

  /**
   * users.profile
   */
  export type users$profileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the profiles
     */
    select?: profilesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the profiles
     */
    omit?: profilesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: profilesInclude<ExtArgs> | null
    where?: profilesWhereInput
  }

  /**
   * users.sessions
   */
  export type users$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    where?: sessionsWhereInput
    orderBy?: sessionsOrderByWithRelationInput | sessionsOrderByWithRelationInput[]
    cursor?: sessionsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SessionsScalarFieldEnum | SessionsScalarFieldEnum[]
  }

  /**
   * users.timelines
   */
  export type users$timelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    where?: timelinesWhereInput
    orderBy?: timelinesOrderByWithRelationInput | timelinesOrderByWithRelationInput[]
    cursor?: timelinesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TimelinesScalarFieldEnum | TimelinesScalarFieldEnum[]
  }

  /**
   * users.task
   */
  export type users$taskArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    where?: taskWhereInput
    orderBy?: taskOrderByWithRelationInput | taskOrderByWithRelationInput[]
    cursor?: taskWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
  }

  /**
   * users.sentMessages
   */
  export type users$sentMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    cursor?: messagesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }

  /**
   * users.receivedMessages
   */
  export type users$receivedMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    cursor?: messagesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }

  /**
   * users.projects
   */
  export type users$projectsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    where?: projectsWhereInput
    orderBy?: projectsOrderByWithRelationInput | projectsOrderByWithRelationInput[]
    cursor?: projectsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProjectsScalarFieldEnum | ProjectsScalarFieldEnum[]
  }

  /**
   * users.inbox
   */
  export type users$inboxArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    where?: inboxWhereInput
  }

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


  /**
   * Model roles
   */

  export type AggregateRoles = {
    _count: RolesCountAggregateOutputType | null
    _min: RolesMinAggregateOutputType | null
    _max: RolesMaxAggregateOutputType | null
  }

  export type RolesMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type RolesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type RolesCountAggregateOutputType = {
    id: number
    name: number
    description: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type RolesMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
  }

  export type RolesMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
  }

  export type RolesCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type rolesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: rolesWhereInput
    orderBy?: rolesOrderByWithAggregationInput | rolesOrderByWithAggregationInput[]
    by: RolesScalarFieldEnum[] | RolesScalarFieldEnum
    having?: rolesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RolesCountAggregateInputType | true
    _min?: RolesMinAggregateInputType
    _max?: RolesMaxAggregateInputType
  }

  export type RolesGroupByOutputType = {
    id: string
    name: string
    description: string | null
    created_at: Date
    updated_at: Date
    _count: RolesCountAggregateOutputType | null
    _min: RolesMinAggregateOutputType | null
    _max: RolesMaxAggregateOutputType | null
  }

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


  export type rolesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    officers?: boolean | roles$officersArgs<ExtArgs>
    permissions?: boolean | roles$permissionsArgs<ExtArgs>
    users?: boolean | roles$usersArgs<ExtArgs>
    _count?: boolean | RolesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["roles"]>

  export type rolesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["roles"]>

  export type rolesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["roles"]>

  export type rolesSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type rolesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "created_at" | "updated_at", ExtArgs["result"]["roles"]>
  export type rolesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    officers?: boolean | roles$officersArgs<ExtArgs>
    permissions?: boolean | roles$permissionsArgs<ExtArgs>
    users?: boolean | roles$usersArgs<ExtArgs>
    _count?: boolean | RolesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type rolesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type rolesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $rolesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "roles"
    objects: {
      officers: Prisma.$officersPayload<ExtArgs>[]
      permissions: Prisma.$permissionsPayload<ExtArgs>[]
      users: Prisma.$usersPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["roles"]>
    composites: {}
  }

  type rolesGetPayload<S extends boolean | null | undefined | rolesDefaultArgs> = $Result.GetResult<Prisma.$rolesPayload, S>

  type rolesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<rolesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: RolesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Roles.
     * @param {rolesCreateArgs} args - Arguments to create a Roles.
     * @example
     * // Create one Roles
     * const Roles = await prisma.roles.create({
     *   data: {
     *     // ... data to create a Roles
     *   }
     * })
     * 
     */
    create<T extends rolesCreateArgs>(args: SelectSubset<T, rolesCreateArgs<ExtArgs>>): Prisma__rolesClient<$Result.GetResult<Prisma.$rolesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Roles.
     * @param {rolesDeleteArgs} args - Arguments to delete one Roles.
     * @example
     * // Delete one Roles
     * const Roles = await prisma.roles.delete({
     *   where: {
     *     // ... filter to delete one Roles
     *   }
     * })
     * 
     */
    delete<T extends rolesDeleteArgs>(args: SelectSubset<T, rolesDeleteArgs<ExtArgs>>): Prisma__rolesClient<$Result.GetResult<Prisma.$rolesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the roles model
   */
  interface rolesFieldRefs {
    readonly id: FieldRef<"roles", 'String'>
    readonly name: FieldRef<"roles", 'String'>
    readonly description: FieldRef<"roles", 'String'>
    readonly created_at: FieldRef<"roles", 'DateTime'>
    readonly updated_at: FieldRef<"roles", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * roles findUnique
   */
  export type rolesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * Filter, which roles to fetch.
     */
    where: rolesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * roles findUniqueOrThrow
   */
  export type rolesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * Filter, which roles to fetch.
     */
    where: rolesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * roles findMany
   */
  export type rolesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * Filter, which roles to fetch.
     */
    where?: rolesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of roles to fetch.
     */
    orderBy?: rolesOrderByWithRelationInput | rolesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing roles.
     */
    cursor?: rolesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` roles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` roles.
     */
    skip?: number
    distinct?: RolesScalarFieldEnum | RolesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * roles create
   */
  export type rolesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * The data needed to create a roles.
     */
    data: XOR<rolesCreateInput, rolesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * roles createManyAndReturn
   */
  export type rolesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * The data used to create many roles.
     */
    data: rolesCreateManyInput | rolesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * roles update
   */
  export type rolesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * The data needed to update a roles.
     */
    data: XOR<rolesUpdateInput, rolesUncheckedUpdateInput>
    /**
     * Choose, which roles to update.
     */
    where: rolesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * roles updateMany
   */
  export type rolesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update roles.
     */
    data: XOR<rolesUpdateManyMutationInput, rolesUncheckedUpdateManyInput>
    /**
     * Filter which roles to update
     */
    where?: rolesWhereInput
    /**
     * Limit how many roles to update.
     */
    limit?: number
  }

  /**
   * roles updateManyAndReturn
   */
  export type rolesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * The data used to update roles.
     */
    data: XOR<rolesUpdateManyMutationInput, rolesUncheckedUpdateManyInput>
    /**
     * Filter which roles to update
     */
    where?: rolesWhereInput
    /**
     * Limit how many roles to update.
     */
    limit?: number
  }

  /**
   * roles upsert
   */
  export type rolesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * The filter to search for the roles to update in case it exists.
     */
    where: rolesWhereUniqueInput
    /**
     * In case the roles found by the `where` argument doesn't exist, create a new roles with this data.
     */
    create: XOR<rolesCreateInput, rolesUncheckedCreateInput>
    /**
     * In case the roles was found with the provided `where` argument, update it with this data.
     */
    update: XOR<rolesUpdateInput, rolesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * roles delete
   */
  export type rolesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the roles
     */
    select?: rolesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the roles
     */
    omit?: rolesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: rolesInclude<ExtArgs> | null
    /**
     * Filter which roles to delete.
     */
    where: rolesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * roles.officers
   */
  export type roles$officersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
    orderBy?: officersOrderByWithRelationInput | officersOrderByWithRelationInput[]
    cursor?: officersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OfficersScalarFieldEnum | OfficersScalarFieldEnum[]
  }

  /**
   * roles.permissions
   */
  export type roles$permissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    where?: permissionsWhereInput
    orderBy?: permissionsOrderByWithRelationInput | permissionsOrderByWithRelationInput[]
    cursor?: permissionsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PermissionsScalarFieldEnum | PermissionsScalarFieldEnum[]
  }

  /**
   * roles.users
   */
  export type roles$usersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    where?: usersWhereInput
    orderBy?: usersOrderByWithRelationInput | usersOrderByWithRelationInput[]
    cursor?: usersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UsersScalarFieldEnum | UsersScalarFieldEnum[]
  }

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


  /**
   * Model sessions
   */

  export type AggregateSessions = {
    _count: SessionsCountAggregateOutputType | null
    _min: SessionsMinAggregateOutputType | null
    _max: SessionsMaxAggregateOutputType | null
  }

  export type SessionsMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    event_id: string | null
    status: $Enums.session_status | null
    created_at: Date | null
  }

  export type SessionsMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    event_id: string | null
    status: $Enums.session_status | null
    created_at: Date | null
  }

  export type SessionsCountAggregateOutputType = {
    id: number
    user_id: number
    event_id: number
    status: number
    created_at: number
    _all: number
  }


  export type SessionsMinAggregateInputType = {
    id?: true
    user_id?: true
    event_id?: true
    status?: true
    created_at?: true
  }

  export type SessionsMaxAggregateInputType = {
    id?: true
    user_id?: true
    event_id?: true
    status?: true
    created_at?: true
  }

  export type SessionsCountAggregateInputType = {
    id?: true
    user_id?: true
    event_id?: true
    status?: true
    created_at?: true
    _all?: true
  }

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

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




  export type sessionsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: sessionsWhereInput
    orderBy?: sessionsOrderByWithAggregationInput | sessionsOrderByWithAggregationInput[]
    by: SessionsScalarFieldEnum[] | SessionsScalarFieldEnum
    having?: sessionsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SessionsCountAggregateInputType | true
    _min?: SessionsMinAggregateInputType
    _max?: SessionsMaxAggregateInputType
  }

  export type SessionsGroupByOutputType = {
    id: string
    user_id: string
    event_id: string
    status: $Enums.session_status
    created_at: Date
    _count: SessionsCountAggregateOutputType | null
    _min: SessionsMinAggregateOutputType | null
    _max: SessionsMaxAggregateOutputType | null
  }

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


  export type sessionsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    event_id?: boolean
    status?: boolean
    created_at?: boolean
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["sessions"]>

  export type sessionsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    event_id?: boolean
    status?: boolean
    created_at?: boolean
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["sessions"]>

  export type sessionsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    event_id?: boolean
    status?: boolean
    created_at?: boolean
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["sessions"]>

  export type sessionsSelectScalar = {
    id?: boolean
    user_id?: boolean
    event_id?: boolean
    status?: boolean
    created_at?: boolean
  }

  export type sessionsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "event_id" | "status" | "created_at", ExtArgs["result"]["sessions"]>
  export type sessionsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type sessionsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type sessionsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    event?: boolean | eventsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $sessionsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "sessions"
    objects: {
      event: Prisma.$eventsPayload<ExtArgs>
      user: Prisma.$usersPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      event_id: string
      status: $Enums.session_status
      created_at: Date
    }, ExtArgs["result"]["sessions"]>
    composites: {}
  }

  type sessionsGetPayload<S extends boolean | null | undefined | sessionsDefaultArgs> = $Result.GetResult<Prisma.$sessionsPayload, S>

  type sessionsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<sessionsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: SessionsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Sessions.
     * @param {sessionsCreateArgs} args - Arguments to create a Sessions.
     * @example
     * // Create one Sessions
     * const Sessions = await prisma.sessions.create({
     *   data: {
     *     // ... data to create a Sessions
     *   }
     * })
     * 
     */
    create<T extends sessionsCreateArgs>(args: SelectSubset<T, sessionsCreateArgs<ExtArgs>>): Prisma__sessionsClient<$Result.GetResult<Prisma.$sessionsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Sessions.
     * @param {sessionsDeleteArgs} args - Arguments to delete one Sessions.
     * @example
     * // Delete one Sessions
     * const Sessions = await prisma.sessions.delete({
     *   where: {
     *     // ... filter to delete one Sessions
     *   }
     * })
     * 
     */
    delete<T extends sessionsDeleteArgs>(args: SelectSubset<T, sessionsDeleteArgs<ExtArgs>>): Prisma__sessionsClient<$Result.GetResult<Prisma.$sessionsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the sessions model
   */
  interface sessionsFieldRefs {
    readonly id: FieldRef<"sessions", 'String'>
    readonly user_id: FieldRef<"sessions", 'String'>
    readonly event_id: FieldRef<"sessions", 'String'>
    readonly status: FieldRef<"sessions", 'session_status'>
    readonly created_at: FieldRef<"sessions", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * sessions findUnique
   */
  export type sessionsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * Filter, which sessions to fetch.
     */
    where: sessionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * sessions findUniqueOrThrow
   */
  export type sessionsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * Filter, which sessions to fetch.
     */
    where: sessionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * sessions findMany
   */
  export type sessionsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * Filter, which sessions to fetch.
     */
    where?: sessionsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of sessions to fetch.
     */
    orderBy?: sessionsOrderByWithRelationInput | sessionsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing sessions.
     */
    cursor?: sessionsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` sessions.
     */
    skip?: number
    distinct?: SessionsScalarFieldEnum | SessionsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * sessions create
   */
  export type sessionsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * The data needed to create a sessions.
     */
    data: XOR<sessionsCreateInput, sessionsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * sessions update
   */
  export type sessionsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * The data needed to update a sessions.
     */
    data: XOR<sessionsUpdateInput, sessionsUncheckedUpdateInput>
    /**
     * Choose, which sessions to update.
     */
    where: sessionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * sessions updateMany
   */
  export type sessionsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update sessions.
     */
    data: XOR<sessionsUpdateManyMutationInput, sessionsUncheckedUpdateManyInput>
    /**
     * Filter which sessions to update
     */
    where?: sessionsWhereInput
    /**
     * Limit how many sessions to update.
     */
    limit?: number
  }

  /**
   * sessions updateManyAndReturn
   */
  export type sessionsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * The data used to update sessions.
     */
    data: XOR<sessionsUpdateManyMutationInput, sessionsUncheckedUpdateManyInput>
    /**
     * Filter which sessions to update
     */
    where?: sessionsWhereInput
    /**
     * Limit how many sessions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * sessions upsert
   */
  export type sessionsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * The filter to search for the sessions to update in case it exists.
     */
    where: sessionsWhereUniqueInput
    /**
     * In case the sessions found by the `where` argument doesn't exist, create a new sessions with this data.
     */
    create: XOR<sessionsCreateInput, sessionsUncheckedCreateInput>
    /**
     * In case the sessions was found with the provided `where` argument, update it with this data.
     */
    update: XOR<sessionsUpdateInput, sessionsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * sessions delete
   */
  export type sessionsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    /**
     * Filter which sessions to delete.
     */
    where: sessionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model events
   */

  export type AggregateEvents = {
    _count: EventsCountAggregateOutputType | null
    _min: EventsMinAggregateOutputType | null
    _max: EventsMaxAggregateOutputType | null
  }

  export type EventsMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    code: string | null
    created_at: Date | null
    user_id: string | null
  }

  export type EventsMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    code: string | null
    created_at: Date | null
    user_id: string | null
  }

  export type EventsCountAggregateOutputType = {
    id: number
    name: number
    description: number
    code: number
    created_at: number
    user_id: number
    _all: number
  }


  export type EventsMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    code?: true
    created_at?: true
    user_id?: true
  }

  export type EventsMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    code?: true
    created_at?: true
    user_id?: true
  }

  export type EventsCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    code?: true
    created_at?: true
    user_id?: true
    _all?: true
  }

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

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




  export type eventsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: eventsWhereInput
    orderBy?: eventsOrderByWithAggregationInput | eventsOrderByWithAggregationInput[]
    by: EventsScalarFieldEnum[] | EventsScalarFieldEnum
    having?: eventsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventsCountAggregateInputType | true
    _min?: EventsMinAggregateInputType
    _max?: EventsMaxAggregateInputType
  }

  export type EventsGroupByOutputType = {
    id: string
    name: string
    description: string | null
    code: string
    created_at: Date
    user_id: string
    _count: EventsCountAggregateOutputType | null
    _min: EventsMinAggregateOutputType | null
    _max: EventsMaxAggregateOutputType | null
  }

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


  export type eventsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    code?: boolean
    created_at?: boolean
    user_id?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
    locations?: boolean | events$locationsArgs<ExtArgs>
    sessions?: boolean | events$sessionsArgs<ExtArgs>
    _count?: boolean | EventsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["events"]>

  export type eventsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    code?: boolean
    created_at?: boolean
    user_id?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["events"]>

  export type eventsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    code?: boolean
    created_at?: boolean
    user_id?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["events"]>

  export type eventsSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    code?: boolean
    created_at?: boolean
    user_id?: boolean
  }

  export type eventsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "code" | "created_at" | "user_id", ExtArgs["result"]["events"]>
  export type eventsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
    locations?: boolean | events$locationsArgs<ExtArgs>
    sessions?: boolean | events$sessionsArgs<ExtArgs>
    _count?: boolean | EventsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type eventsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type eventsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $eventsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "events"
    objects: {
      users: Prisma.$usersPayload<ExtArgs>
      locations: Prisma.$locationsPayload<ExtArgs>[]
      sessions: Prisma.$sessionsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      code: string
      created_at: Date
      user_id: string
    }, ExtArgs["result"]["events"]>
    composites: {}
  }

  type eventsGetPayload<S extends boolean | null | undefined | eventsDefaultArgs> = $Result.GetResult<Prisma.$eventsPayload, S>

  type eventsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<eventsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: EventsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Events.
     * @param {eventsCreateArgs} args - Arguments to create a Events.
     * @example
     * // Create one Events
     * const Events = await prisma.events.create({
     *   data: {
     *     // ... data to create a Events
     *   }
     * })
     * 
     */
    create<T extends eventsCreateArgs>(args: SelectSubset<T, eventsCreateArgs<ExtArgs>>): Prisma__eventsClient<$Result.GetResult<Prisma.$eventsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Events.
     * @param {eventsDeleteArgs} args - Arguments to delete one Events.
     * @example
     * // Delete one Events
     * const Events = await prisma.events.delete({
     *   where: {
     *     // ... filter to delete one Events
     *   }
     * })
     * 
     */
    delete<T extends eventsDeleteArgs>(args: SelectSubset<T, eventsDeleteArgs<ExtArgs>>): Prisma__eventsClient<$Result.GetResult<Prisma.$eventsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the events model
   */
  interface eventsFieldRefs {
    readonly id: FieldRef<"events", 'String'>
    readonly name: FieldRef<"events", 'String'>
    readonly description: FieldRef<"events", 'String'>
    readonly code: FieldRef<"events", 'String'>
    readonly created_at: FieldRef<"events", 'DateTime'>
    readonly user_id: FieldRef<"events", 'String'>
  }
    

  // Custom InputTypes
  /**
   * events findUnique
   */
  export type eventsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * Filter, which events to fetch.
     */
    where: eventsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * events findUniqueOrThrow
   */
  export type eventsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * Filter, which events to fetch.
     */
    where: eventsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * events findMany
   */
  export type eventsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * Filter, which events to fetch.
     */
    where?: eventsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of events to fetch.
     */
    orderBy?: eventsOrderByWithRelationInput | eventsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing events.
     */
    cursor?: eventsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` events from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` events.
     */
    skip?: number
    distinct?: EventsScalarFieldEnum | EventsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * events create
   */
  export type eventsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * The data needed to create a events.
     */
    data: XOR<eventsCreateInput, eventsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * events update
   */
  export type eventsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * The data needed to update a events.
     */
    data: XOR<eventsUpdateInput, eventsUncheckedUpdateInput>
    /**
     * Choose, which events to update.
     */
    where: eventsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * events updateMany
   */
  export type eventsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update events.
     */
    data: XOR<eventsUpdateManyMutationInput, eventsUncheckedUpdateManyInput>
    /**
     * Filter which events to update
     */
    where?: eventsWhereInput
    /**
     * Limit how many events to update.
     */
    limit?: number
  }

  /**
   * events updateManyAndReturn
   */
  export type eventsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * The data used to update events.
     */
    data: XOR<eventsUpdateManyMutationInput, eventsUncheckedUpdateManyInput>
    /**
     * Filter which events to update
     */
    where?: eventsWhereInput
    /**
     * Limit how many events to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * events upsert
   */
  export type eventsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * The filter to search for the events to update in case it exists.
     */
    where: eventsWhereUniqueInput
    /**
     * In case the events found by the `where` argument doesn't exist, create a new events with this data.
     */
    create: XOR<eventsCreateInput, eventsUncheckedCreateInput>
    /**
     * In case the events was found with the provided `where` argument, update it with this data.
     */
    update: XOR<eventsUpdateInput, eventsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * events delete
   */
  export type eventsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the events
     */
    select?: eventsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the events
     */
    omit?: eventsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: eventsInclude<ExtArgs> | null
    /**
     * Filter which events to delete.
     */
    where: eventsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * events.locations
   */
  export type events$locationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    where?: locationsWhereInput
    orderBy?: locationsOrderByWithRelationInput | locationsOrderByWithRelationInput[]
    cursor?: locationsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LocationsScalarFieldEnum | LocationsScalarFieldEnum[]
  }

  /**
   * events.sessions
   */
  export type events$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sessions
     */
    select?: sessionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the sessions
     */
    omit?: sessionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: sessionsInclude<ExtArgs> | null
    where?: sessionsWhereInput
    orderBy?: sessionsOrderByWithRelationInput | sessionsOrderByWithRelationInput[]
    cursor?: sessionsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SessionsScalarFieldEnum | SessionsScalarFieldEnum[]
  }

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


  /**
   * Model resources
   */

  export type AggregateResources = {
    _count: ResourcesCountAggregateOutputType | null
    _min: ResourcesMinAggregateOutputType | null
    _max: ResourcesMaxAggregateOutputType | null
  }

  export type ResourcesMinAggregateOutputType = {
    id: string | null
    name: string | null
    type: string | null
    description: string | null
    instance_role: string | null
    relations: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ResourcesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    type: string | null
    description: string | null
    instance_role: string | null
    relations: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ResourcesCountAggregateOutputType = {
    id: number
    name: number
    type: number
    description: number
    instance_role: number
    relations: number
    attributes: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ResourcesMinAggregateInputType = {
    id?: true
    name?: true
    type?: true
    description?: true
    instance_role?: true
    relations?: true
    created_at?: true
    updated_at?: true
  }

  export type ResourcesMaxAggregateInputType = {
    id?: true
    name?: true
    type?: true
    description?: true
    instance_role?: true
    relations?: true
    created_at?: true
    updated_at?: true
  }

  export type ResourcesCountAggregateInputType = {
    id?: true
    name?: true
    type?: true
    description?: true
    instance_role?: true
    relations?: true
    attributes?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type resourcesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: resourcesWhereInput
    orderBy?: resourcesOrderByWithAggregationInput | resourcesOrderByWithAggregationInput[]
    by: ResourcesScalarFieldEnum[] | ResourcesScalarFieldEnum
    having?: resourcesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ResourcesCountAggregateInputType | true
    _min?: ResourcesMinAggregateInputType
    _max?: ResourcesMaxAggregateInputType
  }

  export type ResourcesGroupByOutputType = {
    id: string
    name: string
    type: string | null
    description: string | null
    instance_role: string | null
    relations: string | null
    attributes: JsonValue | null
    created_at: Date
    updated_at: Date
    _count: ResourcesCountAggregateOutputType | null
    _min: ResourcesMinAggregateOutputType | null
    _max: ResourcesMaxAggregateOutputType | null
  }

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


  export type resourcesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    type?: boolean
    description?: boolean
    instance_role?: boolean
    relations?: boolean
    attributes?: boolean
    created_at?: boolean
    updated_at?: boolean
    permissions?: boolean | resources$permissionsArgs<ExtArgs>
    _count?: boolean | ResourcesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["resources"]>

  export type resourcesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    type?: boolean
    description?: boolean
    instance_role?: boolean
    relations?: boolean
    attributes?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["resources"]>

  export type resourcesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    type?: boolean
    description?: boolean
    instance_role?: boolean
    relations?: boolean
    attributes?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["resources"]>

  export type resourcesSelectScalar = {
    id?: boolean
    name?: boolean
    type?: boolean
    description?: boolean
    instance_role?: boolean
    relations?: boolean
    attributes?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type resourcesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "type" | "description" | "instance_role" | "relations" | "attributes" | "created_at" | "updated_at", ExtArgs["result"]["resources"]>
  export type resourcesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    permissions?: boolean | resources$permissionsArgs<ExtArgs>
    _count?: boolean | ResourcesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type resourcesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type resourcesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $resourcesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "resources"
    objects: {
      permissions: Prisma.$permissionsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      type: string | null
      description: string | null
      instance_role: string | null
      relations: string | null
      attributes: Prisma.JsonValue | null
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["resources"]>
    composites: {}
  }

  type resourcesGetPayload<S extends boolean | null | undefined | resourcesDefaultArgs> = $Result.GetResult<Prisma.$resourcesPayload, S>

  type resourcesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<resourcesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: ResourcesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Resources.
     * @param {resourcesCreateArgs} args - Arguments to create a Resources.
     * @example
     * // Create one Resources
     * const Resources = await prisma.resources.create({
     *   data: {
     *     // ... data to create a Resources
     *   }
     * })
     * 
     */
    create<T extends resourcesCreateArgs>(args: SelectSubset<T, resourcesCreateArgs<ExtArgs>>): Prisma__resourcesClient<$Result.GetResult<Prisma.$resourcesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Resources.
     * @param {resourcesDeleteArgs} args - Arguments to delete one Resources.
     * @example
     * // Delete one Resources
     * const Resources = await prisma.resources.delete({
     *   where: {
     *     // ... filter to delete one Resources
     *   }
     * })
     * 
     */
    delete<T extends resourcesDeleteArgs>(args: SelectSubset<T, resourcesDeleteArgs<ExtArgs>>): Prisma__resourcesClient<$Result.GetResult<Prisma.$resourcesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the resources model
   */
  interface resourcesFieldRefs {
    readonly id: FieldRef<"resources", 'String'>
    readonly name: FieldRef<"resources", 'String'>
    readonly type: FieldRef<"resources", 'String'>
    readonly description: FieldRef<"resources", 'String'>
    readonly instance_role: FieldRef<"resources", 'String'>
    readonly relations: FieldRef<"resources", 'String'>
    readonly attributes: FieldRef<"resources", 'Json'>
    readonly created_at: FieldRef<"resources", 'DateTime'>
    readonly updated_at: FieldRef<"resources", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * resources findUnique
   */
  export type resourcesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * Filter, which resources to fetch.
     */
    where: resourcesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * resources findUniqueOrThrow
   */
  export type resourcesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * Filter, which resources to fetch.
     */
    where: resourcesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * resources findMany
   */
  export type resourcesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * Filter, which resources to fetch.
     */
    where?: resourcesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of resources to fetch.
     */
    orderBy?: resourcesOrderByWithRelationInput | resourcesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing resources.
     */
    cursor?: resourcesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` resources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` resources.
     */
    skip?: number
    distinct?: ResourcesScalarFieldEnum | ResourcesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * resources create
   */
  export type resourcesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * The data needed to create a resources.
     */
    data: XOR<resourcesCreateInput, resourcesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * resources createManyAndReturn
   */
  export type resourcesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * The data used to create many resources.
     */
    data: resourcesCreateManyInput | resourcesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * resources update
   */
  export type resourcesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * The data needed to update a resources.
     */
    data: XOR<resourcesUpdateInput, resourcesUncheckedUpdateInput>
    /**
     * Choose, which resources to update.
     */
    where: resourcesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * resources updateMany
   */
  export type resourcesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update resources.
     */
    data: XOR<resourcesUpdateManyMutationInput, resourcesUncheckedUpdateManyInput>
    /**
     * Filter which resources to update
     */
    where?: resourcesWhereInput
    /**
     * Limit how many resources to update.
     */
    limit?: number
  }

  /**
   * resources updateManyAndReturn
   */
  export type resourcesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * The data used to update resources.
     */
    data: XOR<resourcesUpdateManyMutationInput, resourcesUncheckedUpdateManyInput>
    /**
     * Filter which resources to update
     */
    where?: resourcesWhereInput
    /**
     * Limit how many resources to update.
     */
    limit?: number
  }

  /**
   * resources upsert
   */
  export type resourcesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * The filter to search for the resources to update in case it exists.
     */
    where: resourcesWhereUniqueInput
    /**
     * In case the resources found by the `where` argument doesn't exist, create a new resources with this data.
     */
    create: XOR<resourcesCreateInput, resourcesUncheckedCreateInput>
    /**
     * In case the resources was found with the provided `where` argument, update it with this data.
     */
    update: XOR<resourcesUpdateInput, resourcesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * resources delete
   */
  export type resourcesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the resources
     */
    select?: resourcesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the resources
     */
    omit?: resourcesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: resourcesInclude<ExtArgs> | null
    /**
     * Filter which resources to delete.
     */
    where: resourcesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * resources.permissions
   */
  export type resources$permissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    where?: permissionsWhereInput
    orderBy?: permissionsOrderByWithRelationInput | permissionsOrderByWithRelationInput[]
    cursor?: permissionsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PermissionsScalarFieldEnum | PermissionsScalarFieldEnum[]
  }

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


  /**
   * Model permissions
   */

  export type AggregatePermissions = {
    _count: PermissionsCountAggregateOutputType | null
    _min: PermissionsMinAggregateOutputType | null
    _max: PermissionsMaxAggregateOutputType | null
  }

  export type PermissionsMinAggregateOutputType = {
    id: string | null
    action: string | null
    resource_id: string | null
    role_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type PermissionsMaxAggregateOutputType = {
    id: string | null
    action: string | null
    resource_id: string | null
    role_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type PermissionsCountAggregateOutputType = {
    id: number
    action: number
    resource_id: number
    role_id: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type PermissionsMinAggregateInputType = {
    id?: true
    action?: true
    resource_id?: true
    role_id?: true
    created_at?: true
    updated_at?: true
  }

  export type PermissionsMaxAggregateInputType = {
    id?: true
    action?: true
    resource_id?: true
    role_id?: true
    created_at?: true
    updated_at?: true
  }

  export type PermissionsCountAggregateInputType = {
    id?: true
    action?: true
    resource_id?: true
    role_id?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type permissionsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: permissionsWhereInput
    orderBy?: permissionsOrderByWithAggregationInput | permissionsOrderByWithAggregationInput[]
    by: PermissionsScalarFieldEnum[] | PermissionsScalarFieldEnum
    having?: permissionsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PermissionsCountAggregateInputType | true
    _min?: PermissionsMinAggregateInputType
    _max?: PermissionsMaxAggregateInputType
  }

  export type PermissionsGroupByOutputType = {
    id: string
    action: string
    resource_id: string
    role_id: string
    created_at: Date
    updated_at: Date
    _count: PermissionsCountAggregateOutputType | null
    _min: PermissionsMinAggregateOutputType | null
    _max: PermissionsMaxAggregateOutputType | null
  }

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


  export type permissionsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    resource_id?: boolean
    role_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["permissions"]>

  export type permissionsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    resource_id?: boolean
    role_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["permissions"]>

  export type permissionsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    resource_id?: boolean
    role_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["permissions"]>

  export type permissionsSelectScalar = {
    id?: boolean
    action?: boolean
    resource_id?: boolean
    role_id?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type permissionsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "action" | "resource_id" | "role_id" | "created_at" | "updated_at", ExtArgs["result"]["permissions"]>
  export type permissionsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }
  export type permissionsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }
  export type permissionsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    resource?: boolean | resourcesDefaultArgs<ExtArgs>
    role?: boolean | rolesDefaultArgs<ExtArgs>
  }

  export type $permissionsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "permissions"
    objects: {
      resource: Prisma.$resourcesPayload<ExtArgs>
      role: Prisma.$rolesPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      action: string
      resource_id: string
      role_id: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["permissions"]>
    composites: {}
  }

  type permissionsGetPayload<S extends boolean | null | undefined | permissionsDefaultArgs> = $Result.GetResult<Prisma.$permissionsPayload, S>

  type permissionsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<permissionsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: PermissionsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Permissions.
     * @param {permissionsCreateArgs} args - Arguments to create a Permissions.
     * @example
     * // Create one Permissions
     * const Permissions = await prisma.permissions.create({
     *   data: {
     *     // ... data to create a Permissions
     *   }
     * })
     * 
     */
    create<T extends permissionsCreateArgs>(args: SelectSubset<T, permissionsCreateArgs<ExtArgs>>): Prisma__permissionsClient<$Result.GetResult<Prisma.$permissionsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Permissions.
     * @param {permissionsDeleteArgs} args - Arguments to delete one Permissions.
     * @example
     * // Delete one Permissions
     * const Permissions = await prisma.permissions.delete({
     *   where: {
     *     // ... filter to delete one Permissions
     *   }
     * })
     * 
     */
    delete<T extends permissionsDeleteArgs>(args: SelectSubset<T, permissionsDeleteArgs<ExtArgs>>): Prisma__permissionsClient<$Result.GetResult<Prisma.$permissionsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the permissions model
   */
  interface permissionsFieldRefs {
    readonly id: FieldRef<"permissions", 'String'>
    readonly action: FieldRef<"permissions", 'String'>
    readonly resource_id: FieldRef<"permissions", 'String'>
    readonly role_id: FieldRef<"permissions", 'String'>
    readonly created_at: FieldRef<"permissions", 'DateTime'>
    readonly updated_at: FieldRef<"permissions", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * permissions findUnique
   */
  export type permissionsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * Filter, which permissions to fetch.
     */
    where: permissionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * permissions findUniqueOrThrow
   */
  export type permissionsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * Filter, which permissions to fetch.
     */
    where: permissionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * permissions findMany
   */
  export type permissionsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * Filter, which permissions to fetch.
     */
    where?: permissionsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of permissions to fetch.
     */
    orderBy?: permissionsOrderByWithRelationInput | permissionsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing permissions.
     */
    cursor?: permissionsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` permissions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` permissions.
     */
    skip?: number
    distinct?: PermissionsScalarFieldEnum | PermissionsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * permissions create
   */
  export type permissionsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * The data needed to create a permissions.
     */
    data: XOR<permissionsCreateInput, permissionsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * permissions update
   */
  export type permissionsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * The data needed to update a permissions.
     */
    data: XOR<permissionsUpdateInput, permissionsUncheckedUpdateInput>
    /**
     * Choose, which permissions to update.
     */
    where: permissionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * permissions updateMany
   */
  export type permissionsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update permissions.
     */
    data: XOR<permissionsUpdateManyMutationInput, permissionsUncheckedUpdateManyInput>
    /**
     * Filter which permissions to update
     */
    where?: permissionsWhereInput
    /**
     * Limit how many permissions to update.
     */
    limit?: number
  }

  /**
   * permissions updateManyAndReturn
   */
  export type permissionsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * The data used to update permissions.
     */
    data: XOR<permissionsUpdateManyMutationInput, permissionsUncheckedUpdateManyInput>
    /**
     * Filter which permissions to update
     */
    where?: permissionsWhereInput
    /**
     * Limit how many permissions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * permissions upsert
   */
  export type permissionsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * The filter to search for the permissions to update in case it exists.
     */
    where: permissionsWhereUniqueInput
    /**
     * In case the permissions found by the `where` argument doesn't exist, create a new permissions with this data.
     */
    create: XOR<permissionsCreateInput, permissionsUncheckedCreateInput>
    /**
     * In case the permissions was found with the provided `where` argument, update it with this data.
     */
    update: XOR<permissionsUpdateInput, permissionsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * permissions delete
   */
  export type permissionsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the permissions
     */
    select?: permissionsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the permissions
     */
    omit?: permissionsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: permissionsInclude<ExtArgs> | null
    /**
     * Filter which permissions to delete.
     */
    where: permissionsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model cities
   */

  export type AggregateCities = {
    _count: CitiesCountAggregateOutputType | null
    _min: CitiesMinAggregateOutputType | null
    _max: CitiesMaxAggregateOutputType | null
  }

  export type CitiesMinAggregateOutputType = {
    id: string | null
    name: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type CitiesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type CitiesCountAggregateOutputType = {
    id: number
    name: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type CitiesMinAggregateInputType = {
    id?: true
    name?: true
    created_at?: true
    updated_at?: true
  }

  export type CitiesMaxAggregateInputType = {
    id?: true
    name?: true
    created_at?: true
    updated_at?: true
  }

  export type CitiesCountAggregateInputType = {
    id?: true
    name?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type citiesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: citiesWhereInput
    orderBy?: citiesOrderByWithAggregationInput | citiesOrderByWithAggregationInput[]
    by: CitiesScalarFieldEnum[] | CitiesScalarFieldEnum
    having?: citiesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CitiesCountAggregateInputType | true
    _min?: CitiesMinAggregateInputType
    _max?: CitiesMaxAggregateInputType
  }

  export type CitiesGroupByOutputType = {
    id: string
    name: string
    created_at: Date | null
    updated_at: Date | null
    _count: CitiesCountAggregateOutputType | null
    _min: CitiesMinAggregateOutputType | null
    _max: CitiesMaxAggregateOutputType | null
  }

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


  export type citiesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
    districts?: boolean | cities$districtsArgs<ExtArgs>
    units?: boolean | cities$unitsArgs<ExtArgs>
    _count?: boolean | CitiesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["cities"]>

  export type citiesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["cities"]>

  export type citiesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["cities"]>

  export type citiesSelectScalar = {
    id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type citiesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "created_at" | "updated_at", ExtArgs["result"]["cities"]>
  export type citiesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | cities$districtsArgs<ExtArgs>
    units?: boolean | cities$unitsArgs<ExtArgs>
    _count?: boolean | CitiesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type citiesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type citiesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $citiesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "cities"
    objects: {
      districts: Prisma.$districtsPayload<ExtArgs>[]
      units: Prisma.$unitsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["cities"]>
    composites: {}
  }

  type citiesGetPayload<S extends boolean | null | undefined | citiesDefaultArgs> = $Result.GetResult<Prisma.$citiesPayload, S>

  type citiesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<citiesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: CitiesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Cities.
     * @param {citiesCreateArgs} args - Arguments to create a Cities.
     * @example
     * // Create one Cities
     * const Cities = await prisma.cities.create({
     *   data: {
     *     // ... data to create a Cities
     *   }
     * })
     * 
     */
    create<T extends citiesCreateArgs>(args: SelectSubset<T, citiesCreateArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Cities.
     * @param {citiesDeleteArgs} args - Arguments to delete one Cities.
     * @example
     * // Delete one Cities
     * const Cities = await prisma.cities.delete({
     *   where: {
     *     // ... filter to delete one Cities
     *   }
     * })
     * 
     */
    delete<T extends citiesDeleteArgs>(args: SelectSubset<T, citiesDeleteArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the cities model
   */
  interface citiesFieldRefs {
    readonly id: FieldRef<"cities", 'String'>
    readonly name: FieldRef<"cities", 'String'>
    readonly created_at: FieldRef<"cities", 'DateTime'>
    readonly updated_at: FieldRef<"cities", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * cities findUnique
   */
  export type citiesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * Filter, which cities to fetch.
     */
    where: citiesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cities findUniqueOrThrow
   */
  export type citiesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * Filter, which cities to fetch.
     */
    where: citiesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * cities findMany
   */
  export type citiesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * Filter, which cities to fetch.
     */
    where?: citiesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of cities to fetch.
     */
    orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing cities.
     */
    cursor?: citiesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` cities from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` cities.
     */
    skip?: number
    distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cities create
   */
  export type citiesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * The data needed to create a cities.
     */
    data: XOR<citiesCreateInput, citiesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * cities createManyAndReturn
   */
  export type citiesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * The data used to create many cities.
     */
    data: citiesCreateManyInput | citiesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * cities update
   */
  export type citiesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * The data needed to update a cities.
     */
    data: XOR<citiesUpdateInput, citiesUncheckedUpdateInput>
    /**
     * Choose, which cities to update.
     */
    where: citiesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cities updateMany
   */
  export type citiesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update cities.
     */
    data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyInput>
    /**
     * Filter which cities to update
     */
    where?: citiesWhereInput
    /**
     * Limit how many cities to update.
     */
    limit?: number
  }

  /**
   * cities updateManyAndReturn
   */
  export type citiesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * The data used to update cities.
     */
    data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyInput>
    /**
     * Filter which cities to update
     */
    where?: citiesWhereInput
    /**
     * Limit how many cities to update.
     */
    limit?: number
  }

  /**
   * cities upsert
   */
  export type citiesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * The filter to search for the cities to update in case it exists.
     */
    where: citiesWhereUniqueInput
    /**
     * In case the cities found by the `where` argument doesn't exist, create a new cities with this data.
     */
    create: XOR<citiesCreateInput, citiesUncheckedCreateInput>
    /**
     * In case the cities was found with the provided `where` argument, update it with this data.
     */
    update: XOR<citiesUpdateInput, citiesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cities delete
   */
  export type citiesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cities
     */
    select?: citiesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cities
     */
    omit?: citiesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: citiesInclude<ExtArgs> | null
    /**
     * Filter which cities to delete.
     */
    where: citiesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * cities.districts
   */
  export type cities$districtsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    where?: districtsWhereInput
    orderBy?: districtsOrderByWithRelationInput | districtsOrderByWithRelationInput[]
    cursor?: districtsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DistrictsScalarFieldEnum | DistrictsScalarFieldEnum[]
  }

  /**
   * cities.units
   */
  export type cities$unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    where?: unitsWhereInput
    orderBy?: unitsOrderByWithRelationInput | unitsOrderByWithRelationInput[]
    cursor?: unitsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UnitsScalarFieldEnum | UnitsScalarFieldEnum[]
  }

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


  /**
   * Model crime_incidents
   */

  export type AggregateCrime_incidents = {
    _count: Crime_incidentsCountAggregateOutputType | null
    _avg: Crime_incidentsAvgAggregateOutputType | null
    _sum: Crime_incidentsSumAggregateOutputType | null
    _min: Crime_incidentsMinAggregateOutputType | null
    _max: Crime_incidentsMaxAggregateOutputType | null
  }

  export type Crime_incidentsAvgAggregateOutputType = {
    victim_count: number | null
  }

  export type Crime_incidentsSumAggregateOutputType = {
    victim_count: number | null
  }

  export type Crime_incidentsMinAggregateOutputType = {
    id: string | null
    crime_id: string | null
    crime_category_id: string | null
    location_id: string | null
    description: string | null
    victim_count: number | null
    status: $Enums.crime_status | null
    created_at: Date | null
    updated_at: Date | null
    timestamp: Date | null
  }

  export type Crime_incidentsMaxAggregateOutputType = {
    id: string | null
    crime_id: string | null
    crime_category_id: string | null
    location_id: string | null
    description: string | null
    victim_count: number | null
    status: $Enums.crime_status | null
    created_at: Date | null
    updated_at: Date | null
    timestamp: Date | null
  }

  export type Crime_incidentsCountAggregateOutputType = {
    id: number
    crime_id: number
    crime_category_id: number
    location_id: number
    description: number
    victim_count: number
    status: number
    created_at: number
    updated_at: number
    timestamp: number
    _all: number
  }


  export type Crime_incidentsAvgAggregateInputType = {
    victim_count?: true
  }

  export type Crime_incidentsSumAggregateInputType = {
    victim_count?: true
  }

  export type Crime_incidentsMinAggregateInputType = {
    id?: true
    crime_id?: true
    crime_category_id?: true
    location_id?: true
    description?: true
    victim_count?: true
    status?: true
    created_at?: true
    updated_at?: true
    timestamp?: true
  }

  export type Crime_incidentsMaxAggregateInputType = {
    id?: true
    crime_id?: true
    crime_category_id?: true
    location_id?: true
    description?: true
    victim_count?: true
    status?: true
    created_at?: true
    updated_at?: true
    timestamp?: true
  }

  export type Crime_incidentsCountAggregateInputType = {
    id?: true
    crime_id?: true
    crime_category_id?: true
    location_id?: true
    description?: true
    victim_count?: true
    status?: true
    created_at?: true
    updated_at?: true
    timestamp?: true
    _all?: true
  }

  export type Crime_incidentsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which crime_incidents to aggregate.
     */
    where?: crime_incidentsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of crime_incidents to fetch.
     */
    orderBy?: crime_incidentsOrderByWithRelationInput | crime_incidentsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: crime_incidentsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` crime_incidents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` crime_incidents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned crime_incidents
    **/
    _count?: true | Crime_incidentsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Crime_incidentsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Crime_incidentsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Crime_incidentsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Crime_incidentsMaxAggregateInputType
  }

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




  export type crime_incidentsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crime_incidentsWhereInput
    orderBy?: crime_incidentsOrderByWithAggregationInput | crime_incidentsOrderByWithAggregationInput[]
    by: Crime_incidentsScalarFieldEnum[] | Crime_incidentsScalarFieldEnum
    having?: crime_incidentsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Crime_incidentsCountAggregateInputType | true
    _avg?: Crime_incidentsAvgAggregateInputType
    _sum?: Crime_incidentsSumAggregateInputType
    _min?: Crime_incidentsMinAggregateInputType
    _max?: Crime_incidentsMaxAggregateInputType
  }

  export type Crime_incidentsGroupByOutputType = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status: $Enums.crime_status | null
    created_at: Date | null
    updated_at: Date | null
    timestamp: Date
    _count: Crime_incidentsCountAggregateOutputType | null
    _avg: Crime_incidentsAvgAggregateOutputType | null
    _sum: Crime_incidentsSumAggregateOutputType | null
    _min: Crime_incidentsMinAggregateOutputType | null
    _max: Crime_incidentsMaxAggregateOutputType | null
  }

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


  export type crime_incidentsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_id?: boolean
    crime_category_id?: boolean
    location_id?: boolean
    description?: boolean
    victim_count?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    timestamp?: boolean
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    evidences?: boolean | crime_incidents$evidencesArgs<ExtArgs>
    timelines?: boolean | crime_incidents$timelinesArgs<ExtArgs>
    witnesses?: boolean | crime_incidents$witnessesArgs<ExtArgs>
    _count?: boolean | Crime_incidentsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crime_incidents"]>

  export type crime_incidentsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_id?: boolean
    crime_category_id?: boolean
    location_id?: boolean
    description?: boolean
    victim_count?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    timestamp?: boolean
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crime_incidents"]>

  export type crime_incidentsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_id?: boolean
    crime_category_id?: boolean
    location_id?: boolean
    description?: boolean
    victim_count?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    timestamp?: boolean
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crime_incidents"]>

  export type crime_incidentsSelectScalar = {
    id?: boolean
    crime_id?: boolean
    crime_category_id?: boolean
    location_id?: boolean
    description?: boolean
    victim_count?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    timestamp?: boolean
  }

  export type crime_incidentsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "crime_id" | "crime_category_id" | "location_id" | "description" | "victim_count" | "status" | "created_at" | "updated_at" | "timestamp", ExtArgs["result"]["crime_incidents"]>
  export type crime_incidentsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    evidences?: boolean | crime_incidents$evidencesArgs<ExtArgs>
    timelines?: boolean | crime_incidents$timelinesArgs<ExtArgs>
    witnesses?: boolean | crime_incidents$witnessesArgs<ExtArgs>
    _count?: boolean | Crime_incidentsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type crime_incidentsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
  }
  export type crime_incidentsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    crimes?: boolean | crimesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
  }

  export type $crime_incidentsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "crime_incidents"
    objects: {
      crime_categories: Prisma.$crime_categoriesPayload<ExtArgs>
      crimes: Prisma.$crimesPayload<ExtArgs>
      locations: Prisma.$locationsPayload<ExtArgs>
      evidences: Prisma.$evidencePayload<ExtArgs>[]
      timelines: Prisma.$timelinesPayload<ExtArgs>[]
      witnesses: Prisma.$witnessesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      crime_id: string
      crime_category_id: string
      location_id: string
      description: string
      victim_count: number
      status: $Enums.crime_status | null
      created_at: Date | null
      updated_at: Date | null
      timestamp: Date
    }, ExtArgs["result"]["crime_incidents"]>
    composites: {}
  }

  type crime_incidentsGetPayload<S extends boolean | null | undefined | crime_incidentsDefaultArgs> = $Result.GetResult<Prisma.$crime_incidentsPayload, S>

  type crime_incidentsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<crime_incidentsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Crime_incidentsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Crime_incidents.
     * @param {crime_incidentsCreateArgs} args - Arguments to create a Crime_incidents.
     * @example
     * // Create one Crime_incidents
     * const Crime_incidents = await prisma.crime_incidents.create({
     *   data: {
     *     // ... data to create a Crime_incidents
     *   }
     * })
     * 
     */
    create<T extends crime_incidentsCreateArgs>(args: SelectSubset<T, crime_incidentsCreateArgs<ExtArgs>>): Prisma__crime_incidentsClient<$Result.GetResult<Prisma.$crime_incidentsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Crime_incidents.
     * @param {crime_incidentsDeleteArgs} args - Arguments to delete one Crime_incidents.
     * @example
     * // Delete one Crime_incidents
     * const Crime_incidents = await prisma.crime_incidents.delete({
     *   where: {
     *     // ... filter to delete one Crime_incidents
     *   }
     * })
     * 
     */
    delete<T extends crime_incidentsDeleteArgs>(args: SelectSubset<T, crime_incidentsDeleteArgs<ExtArgs>>): Prisma__crime_incidentsClient<$Result.GetResult<Prisma.$crime_incidentsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for crime_incidents.
   * 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__crime_incidentsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    crime_categories<T extends crime_categoriesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, crime_categoriesDefaultArgs<ExtArgs>>): Prisma__crime_categoriesClient<$Result.GetResult<Prisma.$crime_categoriesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    crimes<T extends crimesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, crimesDefaultArgs<ExtArgs>>): Prisma__crimesClient<$Result.GetResult<Prisma.$crimesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    locations<T extends locationsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, locationsDefaultArgs<ExtArgs>>): Prisma__locationsClient<$Result.GetResult<Prisma.$locationsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    evidences<T extends crime_incidents$evidencesArgs<ExtArgs> = {}>(args?: Subset<T, crime_incidents$evidencesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$evidencePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    timelines<T extends crime_incidents$timelinesArgs<ExtArgs> = {}>(args?: Subset<T, crime_incidents$timelinesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$timelinesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    witnesses<T extends crime_incidents$witnessesArgs<ExtArgs> = {}>(args?: Subset<T, crime_incidents$witnessesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$witnessesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the crime_incidents model
   */
  interface crime_incidentsFieldRefs {
    readonly id: FieldRef<"crime_incidents", 'String'>
    readonly crime_id: FieldRef<"crime_incidents", 'String'>
    readonly crime_category_id: FieldRef<"crime_incidents", 'String'>
    readonly location_id: FieldRef<"crime_incidents", 'String'>
    readonly description: FieldRef<"crime_incidents", 'String'>
    readonly victim_count: FieldRef<"crime_incidents", 'Int'>
    readonly status: FieldRef<"crime_incidents", 'crime_status'>
    readonly created_at: FieldRef<"crime_incidents", 'DateTime'>
    readonly updated_at: FieldRef<"crime_incidents", 'DateTime'>
    readonly timestamp: FieldRef<"crime_incidents", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * crime_incidents findUnique
   */
  export type crime_incidentsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * Filter, which crime_incidents to fetch.
     */
    where: crime_incidentsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_incidents findUniqueOrThrow
   */
  export type crime_incidentsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * Filter, which crime_incidents to fetch.
     */
    where: crime_incidentsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * crime_incidents findMany
   */
  export type crime_incidentsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * Filter, which crime_incidents to fetch.
     */
    where?: crime_incidentsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of crime_incidents to fetch.
     */
    orderBy?: crime_incidentsOrderByWithRelationInput | crime_incidentsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing crime_incidents.
     */
    cursor?: crime_incidentsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` crime_incidents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` crime_incidents.
     */
    skip?: number
    distinct?: Crime_incidentsScalarFieldEnum | Crime_incidentsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_incidents create
   */
  export type crime_incidentsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * The data needed to create a crime_incidents.
     */
    data: XOR<crime_incidentsCreateInput, crime_incidentsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * crime_incidents update
   */
  export type crime_incidentsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * The data needed to update a crime_incidents.
     */
    data: XOR<crime_incidentsUpdateInput, crime_incidentsUncheckedUpdateInput>
    /**
     * Choose, which crime_incidents to update.
     */
    where: crime_incidentsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_incidents updateMany
   */
  export type crime_incidentsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update crime_incidents.
     */
    data: XOR<crime_incidentsUpdateManyMutationInput, crime_incidentsUncheckedUpdateManyInput>
    /**
     * Filter which crime_incidents to update
     */
    where?: crime_incidentsWhereInput
    /**
     * Limit how many crime_incidents to update.
     */
    limit?: number
  }

  /**
   * crime_incidents updateManyAndReturn
   */
  export type crime_incidentsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * The data used to update crime_incidents.
     */
    data: XOR<crime_incidentsUpdateManyMutationInput, crime_incidentsUncheckedUpdateManyInput>
    /**
     * Filter which crime_incidents to update
     */
    where?: crime_incidentsWhereInput
    /**
     * Limit how many crime_incidents to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * crime_incidents upsert
   */
  export type crime_incidentsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * The filter to search for the crime_incidents to update in case it exists.
     */
    where: crime_incidentsWhereUniqueInput
    /**
     * In case the crime_incidents found by the `where` argument doesn't exist, create a new crime_incidents with this data.
     */
    create: XOR<crime_incidentsCreateInput, crime_incidentsUncheckedCreateInput>
    /**
     * In case the crime_incidents was found with the provided `where` argument, update it with this data.
     */
    update: XOR<crime_incidentsUpdateInput, crime_incidentsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_incidents delete
   */
  export type crime_incidentsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    /**
     * Filter which crime_incidents to delete.
     */
    where: crime_incidentsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * crime_incidents.evidences
   */
  export type crime_incidents$evidencesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    where?: evidenceWhereInput
    orderBy?: evidenceOrderByWithRelationInput | evidenceOrderByWithRelationInput[]
    cursor?: evidenceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EvidenceScalarFieldEnum | EvidenceScalarFieldEnum[]
  }

  /**
   * crime_incidents.timelines
   */
  export type crime_incidents$timelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    where?: timelinesWhereInput
    orderBy?: timelinesOrderByWithRelationInput | timelinesOrderByWithRelationInput[]
    cursor?: timelinesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TimelinesScalarFieldEnum | TimelinesScalarFieldEnum[]
  }

  /**
   * crime_incidents.witnesses
   */
  export type crime_incidents$witnessesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    where?: witnessesWhereInput
    orderBy?: witnessesOrderByWithRelationInput | witnessesOrderByWithRelationInput[]
    cursor?: witnessesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WitnessesScalarFieldEnum | WitnessesScalarFieldEnum[]
  }

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


  /**
   * Model crime_categories
   */

  export type AggregateCrime_categories = {
    _count: Crime_categoriesCountAggregateOutputType | null
    _min: Crime_categoriesMinAggregateOutputType | null
    _max: Crime_categoriesMaxAggregateOutputType | null
  }

  export type Crime_categoriesMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
    type: string | null
  }

  export type Crime_categoriesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
    type: string | null
  }

  export type Crime_categoriesCountAggregateOutputType = {
    id: number
    name: number
    description: number
    created_at: number
    updated_at: number
    type: number
    _all: number
  }


  export type Crime_categoriesMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
    type?: true
  }

  export type Crime_categoriesMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
    type?: true
  }

  export type Crime_categoriesCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    created_at?: true
    updated_at?: true
    type?: true
    _all?: true
  }

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

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




  export type crime_categoriesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crime_categoriesWhereInput
    orderBy?: crime_categoriesOrderByWithAggregationInput | crime_categoriesOrderByWithAggregationInput[]
    by: Crime_categoriesScalarFieldEnum[] | Crime_categoriesScalarFieldEnum
    having?: crime_categoriesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Crime_categoriesCountAggregateInputType | true
    _min?: Crime_categoriesMinAggregateInputType
    _max?: Crime_categoriesMaxAggregateInputType
  }

  export type Crime_categoriesGroupByOutputType = {
    id: string
    name: string
    description: string
    created_at: Date | null
    updated_at: Date | null
    type: string | null
    _count: Crime_categoriesCountAggregateOutputType | null
    _min: Crime_categoriesMinAggregateOutputType | null
    _max: Crime_categoriesMaxAggregateOutputType | null
  }

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


  export type crime_categoriesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    type?: boolean
    crime_incidents?: boolean | crime_categories$crime_incidentsArgs<ExtArgs>
    incident_logs?: boolean | crime_categories$incident_logsArgs<ExtArgs>
    _count?: boolean | Crime_categoriesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crime_categories"]>

  export type crime_categoriesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    type?: boolean
  }, ExtArgs["result"]["crime_categories"]>

  export type crime_categoriesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    type?: boolean
  }, ExtArgs["result"]["crime_categories"]>

  export type crime_categoriesSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    type?: boolean
  }

  export type crime_categoriesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "created_at" | "updated_at" | "type", ExtArgs["result"]["crime_categories"]>
  export type crime_categoriesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | crime_categories$crime_incidentsArgs<ExtArgs>
    incident_logs?: boolean | crime_categories$incident_logsArgs<ExtArgs>
    _count?: boolean | Crime_categoriesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type crime_categoriesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type crime_categoriesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $crime_categoriesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "crime_categories"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs>[]
      incident_logs: Prisma.$incident_logsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string
      created_at: Date | null
      updated_at: Date | null
      type: string | null
    }, ExtArgs["result"]["crime_categories"]>
    composites: {}
  }

  type crime_categoriesGetPayload<S extends boolean | null | undefined | crime_categoriesDefaultArgs> = $Result.GetResult<Prisma.$crime_categoriesPayload, S>

  type crime_categoriesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<crime_categoriesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Crime_categoriesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Crime_categories.
     * @param {crime_categoriesCreateArgs} args - Arguments to create a Crime_categories.
     * @example
     * // Create one Crime_categories
     * const Crime_categories = await prisma.crime_categories.create({
     *   data: {
     *     // ... data to create a Crime_categories
     *   }
     * })
     * 
     */
    create<T extends crime_categoriesCreateArgs>(args: SelectSubset<T, crime_categoriesCreateArgs<ExtArgs>>): Prisma__crime_categoriesClient<$Result.GetResult<Prisma.$crime_categoriesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Crime_categories.
     * @param {crime_categoriesDeleteArgs} args - Arguments to delete one Crime_categories.
     * @example
     * // Delete one Crime_categories
     * const Crime_categories = await prisma.crime_categories.delete({
     *   where: {
     *     // ... filter to delete one Crime_categories
     *   }
     * })
     * 
     */
    delete<T extends crime_categoriesDeleteArgs>(args: SelectSubset<T, crime_categoriesDeleteArgs<ExtArgs>>): Prisma__crime_categoriesClient<$Result.GetResult<Prisma.$crime_categoriesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the crime_categories model
   */
  interface crime_categoriesFieldRefs {
    readonly id: FieldRef<"crime_categories", 'String'>
    readonly name: FieldRef<"crime_categories", 'String'>
    readonly description: FieldRef<"crime_categories", 'String'>
    readonly created_at: FieldRef<"crime_categories", 'DateTime'>
    readonly updated_at: FieldRef<"crime_categories", 'DateTime'>
    readonly type: FieldRef<"crime_categories", 'String'>
  }
    

  // Custom InputTypes
  /**
   * crime_categories findUnique
   */
  export type crime_categoriesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * Filter, which crime_categories to fetch.
     */
    where: crime_categoriesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_categories findUniqueOrThrow
   */
  export type crime_categoriesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * Filter, which crime_categories to fetch.
     */
    where: crime_categoriesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * crime_categories findMany
   */
  export type crime_categoriesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * Filter, which crime_categories to fetch.
     */
    where?: crime_categoriesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of crime_categories to fetch.
     */
    orderBy?: crime_categoriesOrderByWithRelationInput | crime_categoriesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing crime_categories.
     */
    cursor?: crime_categoriesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` crime_categories from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` crime_categories.
     */
    skip?: number
    distinct?: Crime_categoriesScalarFieldEnum | Crime_categoriesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_categories create
   */
  export type crime_categoriesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * The data needed to create a crime_categories.
     */
    data: XOR<crime_categoriesCreateInput, crime_categoriesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * crime_categories createManyAndReturn
   */
  export type crime_categoriesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * The data used to create many crime_categories.
     */
    data: crime_categoriesCreateManyInput | crime_categoriesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * crime_categories update
   */
  export type crime_categoriesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * The data needed to update a crime_categories.
     */
    data: XOR<crime_categoriesUpdateInput, crime_categoriesUncheckedUpdateInput>
    /**
     * Choose, which crime_categories to update.
     */
    where: crime_categoriesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_categories updateMany
   */
  export type crime_categoriesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update crime_categories.
     */
    data: XOR<crime_categoriesUpdateManyMutationInput, crime_categoriesUncheckedUpdateManyInput>
    /**
     * Filter which crime_categories to update
     */
    where?: crime_categoriesWhereInput
    /**
     * Limit how many crime_categories to update.
     */
    limit?: number
  }

  /**
   * crime_categories updateManyAndReturn
   */
  export type crime_categoriesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * The data used to update crime_categories.
     */
    data: XOR<crime_categoriesUpdateManyMutationInput, crime_categoriesUncheckedUpdateManyInput>
    /**
     * Filter which crime_categories to update
     */
    where?: crime_categoriesWhereInput
    /**
     * Limit how many crime_categories to update.
     */
    limit?: number
  }

  /**
   * crime_categories upsert
   */
  export type crime_categoriesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * The filter to search for the crime_categories to update in case it exists.
     */
    where: crime_categoriesWhereUniqueInput
    /**
     * In case the crime_categories found by the `where` argument doesn't exist, create a new crime_categories with this data.
     */
    create: XOR<crime_categoriesCreateInput, crime_categoriesUncheckedCreateInput>
    /**
     * In case the crime_categories was found with the provided `where` argument, update it with this data.
     */
    update: XOR<crime_categoriesUpdateInput, crime_categoriesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crime_categories delete
   */
  export type crime_categoriesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_categories
     */
    select?: crime_categoriesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_categories
     */
    omit?: crime_categoriesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_categoriesInclude<ExtArgs> | null
    /**
     * Filter which crime_categories to delete.
     */
    where: crime_categoriesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * crime_categories.crime_incidents
   */
  export type crime_categories$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
    orderBy?: crime_incidentsOrderByWithRelationInput | crime_incidentsOrderByWithRelationInput[]
    cursor?: crime_incidentsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Crime_incidentsScalarFieldEnum | Crime_incidentsScalarFieldEnum[]
  }

  /**
   * crime_categories.incident_logs
   */
  export type crime_categories$incident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
    orderBy?: incident_logsOrderByWithRelationInput | incident_logsOrderByWithRelationInput[]
    cursor?: incident_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Incident_logsScalarFieldEnum | Incident_logsScalarFieldEnum[]
  }

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


  /**
   * Model crimes
   */

  export type AggregateCrimes = {
    _count: CrimesCountAggregateOutputType | null
    _avg: CrimesAvgAggregateOutputType | null
    _sum: CrimesSumAggregateOutputType | null
    _min: CrimesMinAggregateOutputType | null
    _max: CrimesMaxAggregateOutputType | null
  }

  export type CrimesAvgAggregateOutputType = {
    month: number | null
    number_of_crime: number | null
    score: number | null
    year: number | null
    crime_cleared: number | null
    avg_crime: number | null
  }

  export type CrimesSumAggregateOutputType = {
    month: number | null
    number_of_crime: number | null
    score: number | null
    year: number | null
    crime_cleared: number | null
    avg_crime: number | null
  }

  export type CrimesMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    created_at: Date | null
    level: $Enums.crime_rates | null
    method: string | null
    month: number | null
    number_of_crime: number | null
    score: number | null
    updated_at: Date | null
    year: number | null
    source_type: string | null
    crime_cleared: number | null
    avg_crime: number | null
  }

  export type CrimesMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    created_at: Date | null
    level: $Enums.crime_rates | null
    method: string | null
    month: number | null
    number_of_crime: number | null
    score: number | null
    updated_at: Date | null
    year: number | null
    source_type: string | null
    crime_cleared: number | null
    avg_crime: number | null
  }

  export type CrimesCountAggregateOutputType = {
    id: number
    district_id: number
    created_at: number
    level: number
    method: number
    month: number
    number_of_crime: number
    score: number
    updated_at: number
    year: number
    source_type: number
    crime_cleared: number
    avg_crime: number
    _all: number
  }


  export type CrimesAvgAggregateInputType = {
    month?: true
    number_of_crime?: true
    score?: true
    year?: true
    crime_cleared?: true
    avg_crime?: true
  }

  export type CrimesSumAggregateInputType = {
    month?: true
    number_of_crime?: true
    score?: true
    year?: true
    crime_cleared?: true
    avg_crime?: true
  }

  export type CrimesMinAggregateInputType = {
    id?: true
    district_id?: true
    created_at?: true
    level?: true
    method?: true
    month?: true
    number_of_crime?: true
    score?: true
    updated_at?: true
    year?: true
    source_type?: true
    crime_cleared?: true
    avg_crime?: true
  }

  export type CrimesMaxAggregateInputType = {
    id?: true
    district_id?: true
    created_at?: true
    level?: true
    method?: true
    month?: true
    number_of_crime?: true
    score?: true
    updated_at?: true
    year?: true
    source_type?: true
    crime_cleared?: true
    avg_crime?: true
  }

  export type CrimesCountAggregateInputType = {
    id?: true
    district_id?: true
    created_at?: true
    level?: true
    method?: true
    month?: true
    number_of_crime?: true
    score?: true
    updated_at?: true
    year?: true
    source_type?: true
    crime_cleared?: true
    avg_crime?: true
    _all?: true
  }

  export type CrimesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which crimes to aggregate.
     */
    where?: crimesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of crimes to fetch.
     */
    orderBy?: crimesOrderByWithRelationInput | crimesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: crimesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` crimes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` crimes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned crimes
    **/
    _count?: true | CrimesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CrimesAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CrimesSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CrimesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CrimesMaxAggregateInputType
  }

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




  export type crimesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: crimesWhereInput
    orderBy?: crimesOrderByWithAggregationInput | crimesOrderByWithAggregationInput[]
    by: CrimesScalarFieldEnum[] | CrimesScalarFieldEnum
    having?: crimesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CrimesCountAggregateInputType | true
    _avg?: CrimesAvgAggregateInputType
    _sum?: CrimesSumAggregateInputType
    _min?: CrimesMinAggregateInputType
    _max?: CrimesMaxAggregateInputType
  }

  export type CrimesGroupByOutputType = {
    id: string
    district_id: string
    created_at: Date | null
    level: $Enums.crime_rates
    method: string | null
    month: number | null
    number_of_crime: number
    score: number
    updated_at: Date | null
    year: number | null
    source_type: string | null
    crime_cleared: number
    avg_crime: number
    _count: CrimesCountAggregateOutputType | null
    _avg: CrimesAvgAggregateOutputType | null
    _sum: CrimesSumAggregateOutputType | null
    _min: CrimesMinAggregateOutputType | null
    _max: CrimesMaxAggregateOutputType | null
  }

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


  export type crimesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    created_at?: boolean
    level?: boolean
    method?: boolean
    month?: boolean
    number_of_crime?: boolean
    score?: boolean
    updated_at?: boolean
    year?: boolean
    source_type?: boolean
    crime_cleared?: boolean
    avg_crime?: boolean
    crime_incidents?: boolean | crimes$crime_incidentsArgs<ExtArgs>
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    _count?: boolean | CrimesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crimes"]>

  export type crimesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    created_at?: boolean
    level?: boolean
    method?: boolean
    month?: boolean
    number_of_crime?: boolean
    score?: boolean
    updated_at?: boolean
    year?: boolean
    source_type?: boolean
    crime_cleared?: boolean
    avg_crime?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crimes"]>

  export type crimesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    created_at?: boolean
    level?: boolean
    method?: boolean
    month?: boolean
    number_of_crime?: boolean
    score?: boolean
    updated_at?: boolean
    year?: boolean
    source_type?: boolean
    crime_cleared?: boolean
    avg_crime?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["crimes"]>

  export type crimesSelectScalar = {
    id?: boolean
    district_id?: boolean
    created_at?: boolean
    level?: boolean
    method?: boolean
    month?: boolean
    number_of_crime?: boolean
    score?: boolean
    updated_at?: boolean
    year?: boolean
    source_type?: boolean
    crime_cleared?: boolean
    avg_crime?: boolean
  }

  export type crimesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "created_at" | "level" | "method" | "month" | "number_of_crime" | "score" | "updated_at" | "year" | "source_type" | "crime_cleared" | "avg_crime", ExtArgs["result"]["crimes"]>
  export type crimesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | crimes$crime_incidentsArgs<ExtArgs>
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    _count?: boolean | CrimesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type crimesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type crimesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }

  export type $crimesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "crimes"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs>[]
      districts: Prisma.$districtsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      created_at: Date | null
      level: $Enums.crime_rates
      method: string | null
      month: number | null
      number_of_crime: number
      score: number
      updated_at: Date | null
      year: number | null
      source_type: string | null
      crime_cleared: number
      avg_crime: number
    }, ExtArgs["result"]["crimes"]>
    composites: {}
  }

  type crimesGetPayload<S extends boolean | null | undefined | crimesDefaultArgs> = $Result.GetResult<Prisma.$crimesPayload, S>

  type crimesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<crimesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: CrimesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Crimes.
     * @param {crimesCreateArgs} args - Arguments to create a Crimes.
     * @example
     * // Create one Crimes
     * const Crimes = await prisma.crimes.create({
     *   data: {
     *     // ... data to create a Crimes
     *   }
     * })
     * 
     */
    create<T extends crimesCreateArgs>(args: SelectSubset<T, crimesCreateArgs<ExtArgs>>): Prisma__crimesClient<$Result.GetResult<Prisma.$crimesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Crimes.
     * @param {crimesDeleteArgs} args - Arguments to delete one Crimes.
     * @example
     * // Delete one Crimes
     * const Crimes = await prisma.crimes.delete({
     *   where: {
     *     // ... filter to delete one Crimes
     *   }
     * })
     * 
     */
    delete<T extends crimesDeleteArgs>(args: SelectSubset<T, crimesDeleteArgs<ExtArgs>>): Prisma__crimesClient<$Result.GetResult<Prisma.$crimesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the crimes model
   */
  interface crimesFieldRefs {
    readonly id: FieldRef<"crimes", 'String'>
    readonly district_id: FieldRef<"crimes", 'String'>
    readonly created_at: FieldRef<"crimes", 'DateTime'>
    readonly level: FieldRef<"crimes", 'crime_rates'>
    readonly method: FieldRef<"crimes", 'String'>
    readonly month: FieldRef<"crimes", 'Int'>
    readonly number_of_crime: FieldRef<"crimes", 'Int'>
    readonly score: FieldRef<"crimes", 'Float'>
    readonly updated_at: FieldRef<"crimes", 'DateTime'>
    readonly year: FieldRef<"crimes", 'Int'>
    readonly source_type: FieldRef<"crimes", 'String'>
    readonly crime_cleared: FieldRef<"crimes", 'Int'>
    readonly avg_crime: FieldRef<"crimes", 'Float'>
  }
    

  // Custom InputTypes
  /**
   * crimes findUnique
   */
  export type crimesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * Filter, which crimes to fetch.
     */
    where: crimesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crimes findUniqueOrThrow
   */
  export type crimesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * Filter, which crimes to fetch.
     */
    where: crimesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * crimes findMany
   */
  export type crimesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * Filter, which crimes to fetch.
     */
    where?: crimesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of crimes to fetch.
     */
    orderBy?: crimesOrderByWithRelationInput | crimesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing crimes.
     */
    cursor?: crimesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` crimes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` crimes.
     */
    skip?: number
    distinct?: CrimesScalarFieldEnum | CrimesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crimes create
   */
  export type crimesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * The data needed to create a crimes.
     */
    data: XOR<crimesCreateInput, crimesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * crimes update
   */
  export type crimesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * The data needed to update a crimes.
     */
    data: XOR<crimesUpdateInput, crimesUncheckedUpdateInput>
    /**
     * Choose, which crimes to update.
     */
    where: crimesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crimes updateMany
   */
  export type crimesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update crimes.
     */
    data: XOR<crimesUpdateManyMutationInput, crimesUncheckedUpdateManyInput>
    /**
     * Filter which crimes to update
     */
    where?: crimesWhereInput
    /**
     * Limit how many crimes to update.
     */
    limit?: number
  }

  /**
   * crimes updateManyAndReturn
   */
  export type crimesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * The data used to update crimes.
     */
    data: XOR<crimesUpdateManyMutationInput, crimesUncheckedUpdateManyInput>
    /**
     * Filter which crimes to update
     */
    where?: crimesWhereInput
    /**
     * Limit how many crimes to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * crimes upsert
   */
  export type crimesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * The filter to search for the crimes to update in case it exists.
     */
    where: crimesWhereUniqueInput
    /**
     * In case the crimes found by the `where` argument doesn't exist, create a new crimes with this data.
     */
    create: XOR<crimesCreateInput, crimesUncheckedCreateInput>
    /**
     * In case the crimes was found with the provided `where` argument, update it with this data.
     */
    update: XOR<crimesUpdateInput, crimesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * crimes delete
   */
  export type crimesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    /**
     * Filter which crimes to delete.
     */
    where: crimesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * crimes.crime_incidents
   */
  export type crimes$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
    orderBy?: crime_incidentsOrderByWithRelationInput | crime_incidentsOrderByWithRelationInput[]
    cursor?: crime_incidentsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Crime_incidentsScalarFieldEnum | Crime_incidentsScalarFieldEnum[]
  }

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


  /**
   * Model demographics
   */

  export type AggregateDemographics = {
    _count: DemographicsCountAggregateOutputType | null
    _avg: DemographicsAvgAggregateOutputType | null
    _sum: DemographicsSumAggregateOutputType | null
    _min: DemographicsMinAggregateOutputType | null
    _max: DemographicsMaxAggregateOutputType | null
  }

  export type DemographicsAvgAggregateOutputType = {
    population: number | null
    number_of_unemployed: number | null
    population_density: number | null
    year: number | null
  }

  export type DemographicsSumAggregateOutputType = {
    population: number | null
    number_of_unemployed: number | null
    population_density: number | null
    year: number | null
  }

  export type DemographicsMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    population: number | null
    number_of_unemployed: number | null
    population_density: number | null
    year: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type DemographicsMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    population: number | null
    number_of_unemployed: number | null
    population_density: number | null
    year: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type DemographicsCountAggregateOutputType = {
    id: number
    district_id: number
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type DemographicsAvgAggregateInputType = {
    population?: true
    number_of_unemployed?: true
    population_density?: true
    year?: true
  }

  export type DemographicsSumAggregateInputType = {
    population?: true
    number_of_unemployed?: true
    population_density?: true
    year?: true
  }

  export type DemographicsMinAggregateInputType = {
    id?: true
    district_id?: true
    population?: true
    number_of_unemployed?: true
    population_density?: true
    year?: true
    created_at?: true
    updated_at?: true
  }

  export type DemographicsMaxAggregateInputType = {
    id?: true
    district_id?: true
    population?: true
    number_of_unemployed?: true
    population_density?: true
    year?: true
    created_at?: true
    updated_at?: true
  }

  export type DemographicsCountAggregateInputType = {
    id?: true
    district_id?: true
    population?: true
    number_of_unemployed?: true
    population_density?: true
    year?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type DemographicsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which demographics to aggregate.
     */
    where?: demographicsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of demographics to fetch.
     */
    orderBy?: demographicsOrderByWithRelationInput | demographicsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: demographicsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` demographics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` demographics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned demographics
    **/
    _count?: true | DemographicsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DemographicsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DemographicsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DemographicsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DemographicsMaxAggregateInputType
  }

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




  export type demographicsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: demographicsWhereInput
    orderBy?: demographicsOrderByWithAggregationInput | demographicsOrderByWithAggregationInput[]
    by: DemographicsScalarFieldEnum[] | DemographicsScalarFieldEnum
    having?: demographicsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DemographicsCountAggregateInputType | true
    _avg?: DemographicsAvgAggregateInputType
    _sum?: DemographicsSumAggregateInputType
    _min?: DemographicsMinAggregateInputType
    _max?: DemographicsMaxAggregateInputType
  }

  export type DemographicsGroupByOutputType = {
    id: string
    district_id: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at: Date | null
    updated_at: Date | null
    _count: DemographicsCountAggregateOutputType | null
    _avg: DemographicsAvgAggregateOutputType | null
    _sum: DemographicsSumAggregateOutputType | null
    _min: DemographicsMinAggregateOutputType | null
    _max: DemographicsMaxAggregateOutputType | null
  }

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


  export type demographicsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    population?: boolean
    number_of_unemployed?: boolean
    population_density?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["demographics"]>

  export type demographicsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    population?: boolean
    number_of_unemployed?: boolean
    population_density?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["demographics"]>

  export type demographicsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    population?: boolean
    number_of_unemployed?: boolean
    population_density?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["demographics"]>

  export type demographicsSelectScalar = {
    id?: boolean
    district_id?: boolean
    population?: boolean
    number_of_unemployed?: boolean
    population_density?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type demographicsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "population" | "number_of_unemployed" | "population_density" | "year" | "created_at" | "updated_at", ExtArgs["result"]["demographics"]>
  export type demographicsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type demographicsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type demographicsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }

  export type $demographicsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "demographics"
    objects: {
      districts: Prisma.$districtsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      population: number
      number_of_unemployed: number
      population_density: number
      year: number
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["demographics"]>
    composites: {}
  }

  type demographicsGetPayload<S extends boolean | null | undefined | demographicsDefaultArgs> = $Result.GetResult<Prisma.$demographicsPayload, S>

  type demographicsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<demographicsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: DemographicsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Demographics.
     * @param {demographicsCreateArgs} args - Arguments to create a Demographics.
     * @example
     * // Create one Demographics
     * const Demographics = await prisma.demographics.create({
     *   data: {
     *     // ... data to create a Demographics
     *   }
     * })
     * 
     */
    create<T extends demographicsCreateArgs>(args: SelectSubset<T, demographicsCreateArgs<ExtArgs>>): Prisma__demographicsClient<$Result.GetResult<Prisma.$demographicsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Demographics.
     * @param {demographicsDeleteArgs} args - Arguments to delete one Demographics.
     * @example
     * // Delete one Demographics
     * const Demographics = await prisma.demographics.delete({
     *   where: {
     *     // ... filter to delete one Demographics
     *   }
     * })
     * 
     */
    delete<T extends demographicsDeleteArgs>(args: SelectSubset<T, demographicsDeleteArgs<ExtArgs>>): Prisma__demographicsClient<$Result.GetResult<Prisma.$demographicsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the demographics model
   */
  interface demographicsFieldRefs {
    readonly id: FieldRef<"demographics", 'String'>
    readonly district_id: FieldRef<"demographics", 'String'>
    readonly population: FieldRef<"demographics", 'Int'>
    readonly number_of_unemployed: FieldRef<"demographics", 'Int'>
    readonly population_density: FieldRef<"demographics", 'Float'>
    readonly year: FieldRef<"demographics", 'Int'>
    readonly created_at: FieldRef<"demographics", 'DateTime'>
    readonly updated_at: FieldRef<"demographics", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * demographics findUnique
   */
  export type demographicsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * Filter, which demographics to fetch.
     */
    where: demographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * demographics findUniqueOrThrow
   */
  export type demographicsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * Filter, which demographics to fetch.
     */
    where: demographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * demographics findMany
   */
  export type demographicsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * Filter, which demographics to fetch.
     */
    where?: demographicsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of demographics to fetch.
     */
    orderBy?: demographicsOrderByWithRelationInput | demographicsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing demographics.
     */
    cursor?: demographicsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` demographics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` demographics.
     */
    skip?: number
    distinct?: DemographicsScalarFieldEnum | DemographicsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * demographics create
   */
  export type demographicsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * The data needed to create a demographics.
     */
    data: XOR<demographicsCreateInput, demographicsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * demographics update
   */
  export type demographicsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * The data needed to update a demographics.
     */
    data: XOR<demographicsUpdateInput, demographicsUncheckedUpdateInput>
    /**
     * Choose, which demographics to update.
     */
    where: demographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * demographics updateMany
   */
  export type demographicsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update demographics.
     */
    data: XOR<demographicsUpdateManyMutationInput, demographicsUncheckedUpdateManyInput>
    /**
     * Filter which demographics to update
     */
    where?: demographicsWhereInput
    /**
     * Limit how many demographics to update.
     */
    limit?: number
  }

  /**
   * demographics updateManyAndReturn
   */
  export type demographicsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * The data used to update demographics.
     */
    data: XOR<demographicsUpdateManyMutationInput, demographicsUncheckedUpdateManyInput>
    /**
     * Filter which demographics to update
     */
    where?: demographicsWhereInput
    /**
     * Limit how many demographics to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * demographics upsert
   */
  export type demographicsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * The filter to search for the demographics to update in case it exists.
     */
    where: demographicsWhereUniqueInput
    /**
     * In case the demographics found by the `where` argument doesn't exist, create a new demographics with this data.
     */
    create: XOR<demographicsCreateInput, demographicsUncheckedCreateInput>
    /**
     * In case the demographics was found with the provided `where` argument, update it with this data.
     */
    update: XOR<demographicsUpdateInput, demographicsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * demographics delete
   */
  export type demographicsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    /**
     * Filter which demographics to delete.
     */
    where: demographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model districts
   */

  export type AggregateDistricts = {
    _count: DistrictsCountAggregateOutputType | null
    _min: DistrictsMinAggregateOutputType | null
    _max: DistrictsMaxAggregateOutputType | null
  }

  export type DistrictsMinAggregateOutputType = {
    id: string | null
    city_id: string | null
    name: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type DistrictsMaxAggregateOutputType = {
    id: string | null
    city_id: string | null
    name: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type DistrictsCountAggregateOutputType = {
    id: number
    city_id: number
    name: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type DistrictsMinAggregateInputType = {
    id?: true
    city_id?: true
    name?: true
    created_at?: true
    updated_at?: true
  }

  export type DistrictsMaxAggregateInputType = {
    id?: true
    city_id?: true
    name?: true
    created_at?: true
    updated_at?: true
  }

  export type DistrictsCountAggregateInputType = {
    id?: true
    city_id?: true
    name?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type districtsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: districtsWhereInput
    orderBy?: districtsOrderByWithAggregationInput | districtsOrderByWithAggregationInput[]
    by: DistrictsScalarFieldEnum[] | DistrictsScalarFieldEnum
    having?: districtsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DistrictsCountAggregateInputType | true
    _min?: DistrictsMinAggregateInputType
    _max?: DistrictsMaxAggregateInputType
  }

  export type DistrictsGroupByOutputType = {
    id: string
    city_id: string
    name: string
    created_at: Date | null
    updated_at: Date | null
    _count: DistrictsCountAggregateOutputType | null
    _min: DistrictsMinAggregateOutputType | null
    _max: DistrictsMaxAggregateOutputType | null
  }

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


  export type districtsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    city_id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
    crimes?: boolean | districts$crimesArgs<ExtArgs>
    demographics?: boolean | districts$demographicsArgs<ExtArgs>
    district_clusters?: boolean | districts$district_clustersArgs<ExtArgs>
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    geographics?: boolean | districts$geographicsArgs<ExtArgs>
    locations?: boolean | districts$locationsArgs<ExtArgs>
    units?: boolean | districts$unitsArgs<ExtArgs>
    _count?: boolean | DistrictsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["districts"]>

  export type districtsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    city_id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
    cities?: boolean | citiesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["districts"]>

  export type districtsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    city_id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
    cities?: boolean | citiesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["districts"]>

  export type districtsSelectScalar = {
    id?: boolean
    city_id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type districtsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "city_id" | "name" | "created_at" | "updated_at", ExtArgs["result"]["districts"]>
  export type districtsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crimes?: boolean | districts$crimesArgs<ExtArgs>
    demographics?: boolean | districts$demographicsArgs<ExtArgs>
    district_clusters?: boolean | districts$district_clustersArgs<ExtArgs>
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    geographics?: boolean | districts$geographicsArgs<ExtArgs>
    locations?: boolean | districts$locationsArgs<ExtArgs>
    units?: boolean | districts$unitsArgs<ExtArgs>
    _count?: boolean | DistrictsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type districtsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    cities?: boolean | citiesDefaultArgs<ExtArgs>
  }
  export type districtsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    cities?: boolean | citiesDefaultArgs<ExtArgs>
  }

  export type $districtsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "districts"
    objects: {
      crimes: Prisma.$crimesPayload<ExtArgs>[]
      demographics: Prisma.$demographicsPayload<ExtArgs>[]
      district_clusters: Prisma.$district_clustersPayload<ExtArgs>[]
      cities: Prisma.$citiesPayload<ExtArgs>
      geographics: Prisma.$geographicsPayload<ExtArgs>[]
      locations: Prisma.$locationsPayload<ExtArgs>[]
      units: Prisma.$unitsPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      city_id: string
      name: string
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["districts"]>
    composites: {}
  }

  type districtsGetPayload<S extends boolean | null | undefined | districtsDefaultArgs> = $Result.GetResult<Prisma.$districtsPayload, S>

  type districtsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<districtsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: DistrictsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Districts.
     * @param {districtsCreateArgs} args - Arguments to create a Districts.
     * @example
     * // Create one Districts
     * const Districts = await prisma.districts.create({
     *   data: {
     *     // ... data to create a Districts
     *   }
     * })
     * 
     */
    create<T extends districtsCreateArgs>(args: SelectSubset<T, districtsCreateArgs<ExtArgs>>): Prisma__districtsClient<$Result.GetResult<Prisma.$districtsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Districts.
     * @param {districtsDeleteArgs} args - Arguments to delete one Districts.
     * @example
     * // Delete one Districts
     * const Districts = await prisma.districts.delete({
     *   where: {
     *     // ... filter to delete one Districts
     *   }
     * })
     * 
     */
    delete<T extends districtsDeleteArgs>(args: SelectSubset<T, districtsDeleteArgs<ExtArgs>>): Prisma__districtsClient<$Result.GetResult<Prisma.$districtsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for districts.
   * 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__districtsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    crimes<T extends districts$crimesArgs<ExtArgs> = {}>(args?: Subset<T, districts$crimesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$crimesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    demographics<T extends districts$demographicsArgs<ExtArgs> = {}>(args?: Subset<T, districts$demographicsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$demographicsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    district_clusters<T extends districts$district_clustersArgs<ExtArgs> = {}>(args?: Subset<T, districts$district_clustersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$district_clustersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    cities<T extends citiesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, citiesDefaultArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    geographics<T extends districts$geographicsArgs<ExtArgs> = {}>(args?: Subset<T, districts$geographicsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$geographicsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    locations<T extends districts$locationsArgs<ExtArgs> = {}>(args?: Subset<T, districts$locationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$locationsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    units<T extends districts$unitsArgs<ExtArgs> = {}>(args?: Subset<T, districts$unitsArgs<ExtArgs>>): Prisma__unitsClient<$Result.GetResult<Prisma.$unitsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the districts model
   */
  interface districtsFieldRefs {
    readonly id: FieldRef<"districts", 'String'>
    readonly city_id: FieldRef<"districts", 'String'>
    readonly name: FieldRef<"districts", 'String'>
    readonly created_at: FieldRef<"districts", 'DateTime'>
    readonly updated_at: FieldRef<"districts", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * districts findUnique
   */
  export type districtsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * Filter, which districts to fetch.
     */
    where: districtsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * districts findUniqueOrThrow
   */
  export type districtsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * Filter, which districts to fetch.
     */
    where: districtsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * districts findMany
   */
  export type districtsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * Filter, which districts to fetch.
     */
    where?: districtsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of districts to fetch.
     */
    orderBy?: districtsOrderByWithRelationInput | districtsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing districts.
     */
    cursor?: districtsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` districts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` districts.
     */
    skip?: number
    distinct?: DistrictsScalarFieldEnum | DistrictsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * districts create
   */
  export type districtsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * The data needed to create a districts.
     */
    data: XOR<districtsCreateInput, districtsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * districts update
   */
  export type districtsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * The data needed to update a districts.
     */
    data: XOR<districtsUpdateInput, districtsUncheckedUpdateInput>
    /**
     * Choose, which districts to update.
     */
    where: districtsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * districts updateMany
   */
  export type districtsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update districts.
     */
    data: XOR<districtsUpdateManyMutationInput, districtsUncheckedUpdateManyInput>
    /**
     * Filter which districts to update
     */
    where?: districtsWhereInput
    /**
     * Limit how many districts to update.
     */
    limit?: number
  }

  /**
   * districts updateManyAndReturn
   */
  export type districtsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * The data used to update districts.
     */
    data: XOR<districtsUpdateManyMutationInput, districtsUncheckedUpdateManyInput>
    /**
     * Filter which districts to update
     */
    where?: districtsWhereInput
    /**
     * Limit how many districts to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * districts upsert
   */
  export type districtsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * The filter to search for the districts to update in case it exists.
     */
    where: districtsWhereUniqueInput
    /**
     * In case the districts found by the `where` argument doesn't exist, create a new districts with this data.
     */
    create: XOR<districtsCreateInput, districtsUncheckedCreateInput>
    /**
     * In case the districts was found with the provided `where` argument, update it with this data.
     */
    update: XOR<districtsUpdateInput, districtsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * districts delete
   */
  export type districtsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    /**
     * Filter which districts to delete.
     */
    where: districtsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * districts.crimes
   */
  export type districts$crimesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crimes
     */
    select?: crimesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crimes
     */
    omit?: crimesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crimesInclude<ExtArgs> | null
    where?: crimesWhereInput
    orderBy?: crimesOrderByWithRelationInput | crimesOrderByWithRelationInput[]
    cursor?: crimesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CrimesScalarFieldEnum | CrimesScalarFieldEnum[]
  }

  /**
   * districts.demographics
   */
  export type districts$demographicsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the demographics
     */
    select?: demographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the demographics
     */
    omit?: demographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: demographicsInclude<ExtArgs> | null
    where?: demographicsWhereInput
    orderBy?: demographicsOrderByWithRelationInput | demographicsOrderByWithRelationInput[]
    cursor?: demographicsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DemographicsScalarFieldEnum | DemographicsScalarFieldEnum[]
  }

  /**
   * districts.district_clusters
   */
  export type districts$district_clustersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    where?: district_clustersWhereInput
    orderBy?: district_clustersOrderByWithRelationInput | district_clustersOrderByWithRelationInput[]
    cursor?: district_clustersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: District_clustersScalarFieldEnum | District_clustersScalarFieldEnum[]
  }

  /**
   * districts.geographics
   */
  export type districts$geographicsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    where?: geographicsWhereInput
    orderBy?: geographicsOrderByWithRelationInput | geographicsOrderByWithRelationInput[]
    cursor?: geographicsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: GeographicsScalarFieldEnum | GeographicsScalarFieldEnum[]
  }

  /**
   * districts.locations
   */
  export type districts$locationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    where?: locationsWhereInput
    orderBy?: locationsOrderByWithRelationInput | locationsOrderByWithRelationInput[]
    cursor?: locationsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LocationsScalarFieldEnum | LocationsScalarFieldEnum[]
  }

  /**
   * districts.units
   */
  export type districts$unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    where?: unitsWhereInput
  }

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


  /**
   * Model locations
   */

  export type AggregateLocations = {
    _count: LocationsCountAggregateOutputType | null
    _avg: LocationsAvgAggregateOutputType | null
    _sum: LocationsSumAggregateOutputType | null
    _min: LocationsMinAggregateOutputType | null
    _max: LocationsMaxAggregateOutputType | null
  }

  export type LocationsAvgAggregateOutputType = {
    latitude: number | null
    longitude: number | null
    land_area: number | null
    distance_to_unit: number | null
  }

  export type LocationsSumAggregateOutputType = {
    latitude: number | null
    longitude: number | null
    land_area: number | null
    distance_to_unit: number | null
  }

  export type LocationsMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    event_id: string | null
    address: string | null
    type: string | null
    latitude: number | null
    longitude: number | null
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    distance_to_unit: number | null
  }

  export type LocationsMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    event_id: string | null
    address: string | null
    type: string | null
    latitude: number | null
    longitude: number | null
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    distance_to_unit: number | null
  }

  export type LocationsCountAggregateOutputType = {
    id: number
    district_id: number
    event_id: number
    address: number
    type: number
    latitude: number
    longitude: number
    land_area: number
    created_at: number
    updated_at: number
    distance_to_unit: number
    _all: number
  }


  export type LocationsAvgAggregateInputType = {
    latitude?: true
    longitude?: true
    land_area?: true
    distance_to_unit?: true
  }

  export type LocationsSumAggregateInputType = {
    latitude?: true
    longitude?: true
    land_area?: true
    distance_to_unit?: true
  }

  export type LocationsMinAggregateInputType = {
    id?: true
    district_id?: true
    event_id?: true
    address?: true
    type?: true
    latitude?: true
    longitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    distance_to_unit?: true
  }

  export type LocationsMaxAggregateInputType = {
    id?: true
    district_id?: true
    event_id?: true
    address?: true
    type?: true
    latitude?: true
    longitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    distance_to_unit?: true
  }

  export type LocationsCountAggregateInputType = {
    id?: true
    district_id?: true
    event_id?: true
    address?: true
    type?: true
    latitude?: true
    longitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    distance_to_unit?: true
    _all?: true
  }

  export type LocationsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which locations to aggregate.
     */
    where?: locationsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of locations to fetch.
     */
    orderBy?: locationsOrderByWithRelationInput | locationsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: locationsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` locations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` locations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned locations
    **/
    _count?: true | LocationsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: LocationsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: LocationsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LocationsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LocationsMaxAggregateInputType
  }

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




  export type locationsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: locationsWhereInput
    orderBy?: locationsOrderByWithAggregationInput | locationsOrderByWithAggregationInput[]
    by: LocationsScalarFieldEnum[] | LocationsScalarFieldEnum
    having?: locationsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LocationsCountAggregateInputType | true
    _avg?: LocationsAvgAggregateInputType
    _sum?: LocationsSumAggregateInputType
    _min?: LocationsMinAggregateInputType
    _max?: LocationsMaxAggregateInputType
  }

  export type LocationsGroupByOutputType = {
    id: string
    district_id: string
    event_id: string
    address: string | null
    type: string | null
    latitude: number
    longitude: number
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    distance_to_unit: number | null
    _count: LocationsCountAggregateOutputType | null
    _avg: LocationsAvgAggregateOutputType | null
    _sum: LocationsSumAggregateOutputType | null
    _min: LocationsMinAggregateOutputType | null
    _max: LocationsMaxAggregateOutputType | null
  }

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


  export type locationsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    event_id?: boolean
    address?: boolean
    type?: boolean
    latitude?: boolean
    longitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    distance_to_unit?: boolean
    crime_incidents?: boolean | locations$crime_incidentsArgs<ExtArgs>
    incident_logs?: boolean | locations$incident_logsArgs<ExtArgs>
    location_logs?: boolean | locations$location_logsArgs<ExtArgs>
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    event?: boolean | eventsDefaultArgs<ExtArgs>
    patrol_units?: boolean | locations$patrol_unitsArgs<ExtArgs>
    _count?: boolean | LocationsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["locations"]>


  export type locationsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    event_id?: boolean
    address?: boolean
    type?: boolean
    latitude?: boolean
    longitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    distance_to_unit?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    event?: boolean | eventsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["locations"]>

  export type locationsSelectScalar = {
    id?: boolean
    district_id?: boolean
    event_id?: boolean
    address?: boolean
    type?: boolean
    latitude?: boolean
    longitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    distance_to_unit?: boolean
  }

  export type locationsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "event_id" | "address" | "type" | "latitude" | "longitude" | "land_area" | "created_at" | "updated_at" | "distance_to_unit", ExtArgs["result"]["locations"]>
  export type locationsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | locations$crime_incidentsArgs<ExtArgs>
    incident_logs?: boolean | locations$incident_logsArgs<ExtArgs>
    location_logs?: boolean | locations$location_logsArgs<ExtArgs>
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    event?: boolean | eventsDefaultArgs<ExtArgs>
    patrol_units?: boolean | locations$patrol_unitsArgs<ExtArgs>
    _count?: boolean | LocationsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type locationsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
    event?: boolean | eventsDefaultArgs<ExtArgs>
  }

  export type $locationsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "locations"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs>[]
      incident_logs: Prisma.$incident_logsPayload<ExtArgs>[]
      location_logs: Prisma.$location_logsPayload<ExtArgs>[]
      districts: Prisma.$districtsPayload<ExtArgs>
      event: Prisma.$eventsPayload<ExtArgs>
      patrol_units: Prisma.$patrol_unitsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      event_id: string
      address: string | null
      type: string | null
      latitude: number
      longitude: number
      land_area: number | null
      created_at: Date | null
      updated_at: Date | null
      distance_to_unit: number | null
    }, ExtArgs["result"]["locations"]>
    composites: {}
  }

  type locationsGetPayload<S extends boolean | null | undefined | locationsDefaultArgs> = $Result.GetResult<Prisma.$locationsPayload, S>

  type locationsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<locationsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: LocationsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Delete a Locations.
     * @param {locationsDeleteArgs} args - Arguments to delete one Locations.
     * @example
     * // Delete one Locations
     * const Locations = await prisma.locations.delete({
     *   where: {
     *     // ... filter to delete one Locations
     *   }
     * })
     * 
     */
    delete<T extends locationsDeleteArgs>(args: SelectSubset<T, locationsDeleteArgs<ExtArgs>>): Prisma__locationsClient<$Result.GetResult<Prisma.$locationsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for locations.
   * 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__locationsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    crime_incidents<T extends locations$crime_incidentsArgs<ExtArgs> = {}>(args?: Subset<T, locations$crime_incidentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$crime_incidentsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    incident_logs<T extends locations$incident_logsArgs<ExtArgs> = {}>(args?: Subset<T, locations$incident_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$incident_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    location_logs<T extends locations$location_logsArgs<ExtArgs> = {}>(args?: Subset<T, locations$location_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$location_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    districts<T extends districtsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, districtsDefaultArgs<ExtArgs>>): Prisma__districtsClient<$Result.GetResult<Prisma.$districtsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    event<T extends eventsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, eventsDefaultArgs<ExtArgs>>): Prisma__eventsClient<$Result.GetResult<Prisma.$eventsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    patrol_units<T extends locations$patrol_unitsArgs<ExtArgs> = {}>(args?: Subset<T, locations$patrol_unitsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$patrol_unitsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the locations model
   */
  interface locationsFieldRefs {
    readonly id: FieldRef<"locations", 'String'>
    readonly district_id: FieldRef<"locations", 'String'>
    readonly event_id: FieldRef<"locations", 'String'>
    readonly address: FieldRef<"locations", 'String'>
    readonly type: FieldRef<"locations", 'String'>
    readonly latitude: FieldRef<"locations", 'Float'>
    readonly longitude: FieldRef<"locations", 'Float'>
    readonly land_area: FieldRef<"locations", 'Float'>
    readonly created_at: FieldRef<"locations", 'DateTime'>
    readonly updated_at: FieldRef<"locations", 'DateTime'>
    readonly distance_to_unit: FieldRef<"locations", 'Float'>
  }
    

  // Custom InputTypes
  /**
   * locations findUnique
   */
  export type locationsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    /**
     * Filter, which locations to fetch.
     */
    where: locationsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * locations findUniqueOrThrow
   */
  export type locationsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    /**
     * Filter, which locations to fetch.
     */
    where: locationsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * locations findMany
   */
  export type locationsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    /**
     * Filter, which locations to fetch.
     */
    where?: locationsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of locations to fetch.
     */
    orderBy?: locationsOrderByWithRelationInput | locationsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing locations.
     */
    cursor?: locationsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` locations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` locations.
     */
    skip?: number
    distinct?: LocationsScalarFieldEnum | LocationsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * locations update
   */
  export type locationsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    /**
     * The data needed to update a locations.
     */
    data: XOR<locationsUpdateInput, locationsUncheckedUpdateInput>
    /**
     * Choose, which locations to update.
     */
    where: locationsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * locations updateMany
   */
  export type locationsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update locations.
     */
    data: XOR<locationsUpdateManyMutationInput, locationsUncheckedUpdateManyInput>
    /**
     * Filter which locations to update
     */
    where?: locationsWhereInput
    /**
     * Limit how many locations to update.
     */
    limit?: number
  }

  /**
   * locations updateManyAndReturn
   */
  export type locationsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * The data used to update locations.
     */
    data: XOR<locationsUpdateManyMutationInput, locationsUncheckedUpdateManyInput>
    /**
     * Filter which locations to update
     */
    where?: locationsWhereInput
    /**
     * Limit how many locations to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * locations delete
   */
  export type locationsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the locations
     */
    select?: locationsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the locations
     */
    omit?: locationsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: locationsInclude<ExtArgs> | null
    /**
     * Filter which locations to delete.
     */
    where: locationsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * locations.crime_incidents
   */
  export type locations$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
    orderBy?: crime_incidentsOrderByWithRelationInput | crime_incidentsOrderByWithRelationInput[]
    cursor?: crime_incidentsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Crime_incidentsScalarFieldEnum | Crime_incidentsScalarFieldEnum[]
  }

  /**
   * locations.incident_logs
   */
  export type locations$incident_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
    orderBy?: incident_logsOrderByWithRelationInput | incident_logsOrderByWithRelationInput[]
    cursor?: incident_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Incident_logsScalarFieldEnum | Incident_logsScalarFieldEnum[]
  }

  /**
   * locations.location_logs
   */
  export type locations$location_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    where?: location_logsWhereInput
    orderBy?: location_logsOrderByWithRelationInput | location_logsOrderByWithRelationInput[]
    cursor?: location_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Location_logsScalarFieldEnum | Location_logsScalarFieldEnum[]
  }

  /**
   * locations.patrol_units
   */
  export type locations$patrol_unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    where?: patrol_unitsWhereInput
    orderBy?: patrol_unitsOrderByWithRelationInput | patrol_unitsOrderByWithRelationInput[]
    cursor?: patrol_unitsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Patrol_unitsScalarFieldEnum | Patrol_unitsScalarFieldEnum[]
  }

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


  /**
   * Model incident_logs
   */

  export type AggregateIncident_logs = {
    _count: Incident_logsCountAggregateOutputType | null
    _min: Incident_logsMinAggregateOutputType | null
    _max: Incident_logsMaxAggregateOutputType | null
  }

  export type Incident_logsMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    location_id: string | null
    category_id: string | null
    description: string | null
    source: string | null
    time: Date | null
    verified: boolean | null
    severity: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Incident_logsMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    location_id: string | null
    category_id: string | null
    description: string | null
    source: string | null
    time: Date | null
    verified: boolean | null
    severity: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Incident_logsCountAggregateOutputType = {
    id: number
    user_id: number
    location_id: number
    category_id: number
    description: number
    source: number
    time: number
    verified: number
    severity: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type Incident_logsMinAggregateInputType = {
    id?: true
    user_id?: true
    location_id?: true
    category_id?: true
    description?: true
    source?: true
    time?: true
    verified?: true
    severity?: true
    created_at?: true
    updated_at?: true
  }

  export type Incident_logsMaxAggregateInputType = {
    id?: true
    user_id?: true
    location_id?: true
    category_id?: true
    description?: true
    source?: true
    time?: true
    verified?: true
    severity?: true
    created_at?: true
    updated_at?: true
  }

  export type Incident_logsCountAggregateInputType = {
    id?: true
    user_id?: true
    location_id?: true
    category_id?: true
    description?: true
    source?: true
    time?: true
    verified?: true
    severity?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type incident_logsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: incident_logsWhereInput
    orderBy?: incident_logsOrderByWithAggregationInput | incident_logsOrderByWithAggregationInput[]
    by: Incident_logsScalarFieldEnum[] | Incident_logsScalarFieldEnum
    having?: incident_logsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Incident_logsCountAggregateInputType | true
    _min?: Incident_logsMinAggregateInputType
    _max?: Incident_logsMaxAggregateInputType
  }

  export type Incident_logsGroupByOutputType = {
    id: string
    user_id: string
    location_id: string
    category_id: string
    description: string | null
    source: string | null
    time: Date
    verified: boolean | null
    severity: string | null
    created_at: Date | null
    updated_at: Date | null
    _count: Incident_logsCountAggregateOutputType | null
    _min: Incident_logsMinAggregateOutputType | null
    _max: Incident_logsMaxAggregateOutputType | null
  }

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


  export type incident_logsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    location_id?: boolean
    category_id?: boolean
    description?: boolean
    source?: boolean
    time?: boolean
    verified?: boolean
    severity?: boolean
    created_at?: boolean
    updated_at?: boolean
    evidence?: boolean | incident_logs$evidenceArgs<ExtArgs>
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
    panic_button_logs?: boolean | incident_logs$panic_button_logsArgs<ExtArgs>
    timelines?: boolean | incident_logs$timelinesArgs<ExtArgs>
    witnesses?: boolean | incident_logs$witnessesArgs<ExtArgs>
    _count?: boolean | Incident_logsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["incident_logs"]>

  export type incident_logsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    location_id?: boolean
    category_id?: boolean
    description?: boolean
    source?: boolean
    time?: boolean
    verified?: boolean
    severity?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["incident_logs"]>

  export type incident_logsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    location_id?: boolean
    category_id?: boolean
    description?: boolean
    source?: boolean
    time?: boolean
    verified?: boolean
    severity?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["incident_logs"]>

  export type incident_logsSelectScalar = {
    id?: boolean
    user_id?: boolean
    location_id?: boolean
    category_id?: boolean
    description?: boolean
    source?: boolean
    time?: boolean
    verified?: boolean
    severity?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type incident_logsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "location_id" | "category_id" | "description" | "source" | "time" | "verified" | "severity" | "created_at" | "updated_at", ExtArgs["result"]["incident_logs"]>
  export type incident_logsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    evidence?: boolean | incident_logs$evidenceArgs<ExtArgs>
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
    panic_button_logs?: boolean | incident_logs$panic_button_logsArgs<ExtArgs>
    timelines?: boolean | incident_logs$timelinesArgs<ExtArgs>
    witnesses?: boolean | incident_logs$witnessesArgs<ExtArgs>
    _count?: boolean | Incident_logsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type incident_logsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type incident_logsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_categories?: boolean | crime_categoriesDefaultArgs<ExtArgs>
    locations?: boolean | locationsDefaultArgs<ExtArgs>
    user?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $incident_logsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "incident_logs"
    objects: {
      evidence: Prisma.$evidencePayload<ExtArgs>[]
      crime_categories: Prisma.$crime_categoriesPayload<ExtArgs>
      locations: Prisma.$locationsPayload<ExtArgs>
      user: Prisma.$usersPayload<ExtArgs>
      panic_button_logs: Prisma.$panic_button_logsPayload<ExtArgs>[]
      timelines: Prisma.$timelinesPayload<ExtArgs>[]
      witnesses: Prisma.$witnessesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      location_id: string
      category_id: string
      description: string | null
      source: string | null
      time: Date
      verified: boolean | null
      severity: string | null
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["incident_logs"]>
    composites: {}
  }

  type incident_logsGetPayload<S extends boolean | null | undefined | incident_logsDefaultArgs> = $Result.GetResult<Prisma.$incident_logsPayload, S>

  type incident_logsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<incident_logsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Incident_logsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Incident_logs.
     * @param {incident_logsCreateArgs} args - Arguments to create a Incident_logs.
     * @example
     * // Create one Incident_logs
     * const Incident_logs = await prisma.incident_logs.create({
     *   data: {
     *     // ... data to create a Incident_logs
     *   }
     * })
     * 
     */
    create<T extends incident_logsCreateArgs>(args: SelectSubset<T, incident_logsCreateArgs<ExtArgs>>): Prisma__incident_logsClient<$Result.GetResult<Prisma.$incident_logsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Incident_logs.
     * @param {incident_logsDeleteArgs} args - Arguments to delete one Incident_logs.
     * @example
     * // Delete one Incident_logs
     * const Incident_logs = await prisma.incident_logs.delete({
     *   where: {
     *     // ... filter to delete one Incident_logs
     *   }
     * })
     * 
     */
    delete<T extends incident_logsDeleteArgs>(args: SelectSubset<T, incident_logsDeleteArgs<ExtArgs>>): Prisma__incident_logsClient<$Result.GetResult<Prisma.$incident_logsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for incident_logs.
   * 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__incident_logsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    evidence<T extends incident_logs$evidenceArgs<ExtArgs> = {}>(args?: Subset<T, incident_logs$evidenceArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$evidencePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    crime_categories<T extends crime_categoriesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, crime_categoriesDefaultArgs<ExtArgs>>): Prisma__crime_categoriesClient<$Result.GetResult<Prisma.$crime_categoriesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    locations<T extends locationsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, locationsDefaultArgs<ExtArgs>>): Prisma__locationsClient<$Result.GetResult<Prisma.$locationsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends usersDefaultArgs<ExtArgs> = {}>(args?: Subset<T, usersDefaultArgs<ExtArgs>>): Prisma__usersClient<$Result.GetResult<Prisma.$usersPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    panic_button_logs<T extends incident_logs$panic_button_logsArgs<ExtArgs> = {}>(args?: Subset<T, incident_logs$panic_button_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$panic_button_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    timelines<T extends incident_logs$timelinesArgs<ExtArgs> = {}>(args?: Subset<T, incident_logs$timelinesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$timelinesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    witnesses<T extends incident_logs$witnessesArgs<ExtArgs> = {}>(args?: Subset<T, incident_logs$witnessesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$witnessesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the incident_logs model
   */
  interface incident_logsFieldRefs {
    readonly id: FieldRef<"incident_logs", 'String'>
    readonly user_id: FieldRef<"incident_logs", 'String'>
    readonly location_id: FieldRef<"incident_logs", 'String'>
    readonly category_id: FieldRef<"incident_logs", 'String'>
    readonly description: FieldRef<"incident_logs", 'String'>
    readonly source: FieldRef<"incident_logs", 'String'>
    readonly time: FieldRef<"incident_logs", 'DateTime'>
    readonly verified: FieldRef<"incident_logs", 'Boolean'>
    readonly severity: FieldRef<"incident_logs", 'String'>
    readonly created_at: FieldRef<"incident_logs", 'DateTime'>
    readonly updated_at: FieldRef<"incident_logs", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * incident_logs findUnique
   */
  export type incident_logsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * Filter, which incident_logs to fetch.
     */
    where: incident_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * incident_logs findUniqueOrThrow
   */
  export type incident_logsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * Filter, which incident_logs to fetch.
     */
    where: incident_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * incident_logs findMany
   */
  export type incident_logsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * Filter, which incident_logs to fetch.
     */
    where?: incident_logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of incident_logs to fetch.
     */
    orderBy?: incident_logsOrderByWithRelationInput | incident_logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing incident_logs.
     */
    cursor?: incident_logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` incident_logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` incident_logs.
     */
    skip?: number
    distinct?: Incident_logsScalarFieldEnum | Incident_logsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * incident_logs create
   */
  export type incident_logsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * The data needed to create a incident_logs.
     */
    data: XOR<incident_logsCreateInput, incident_logsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * incident_logs update
   */
  export type incident_logsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * The data needed to update a incident_logs.
     */
    data: XOR<incident_logsUpdateInput, incident_logsUncheckedUpdateInput>
    /**
     * Choose, which incident_logs to update.
     */
    where: incident_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * incident_logs updateMany
   */
  export type incident_logsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update incident_logs.
     */
    data: XOR<incident_logsUpdateManyMutationInput, incident_logsUncheckedUpdateManyInput>
    /**
     * Filter which incident_logs to update
     */
    where?: incident_logsWhereInput
    /**
     * Limit how many incident_logs to update.
     */
    limit?: number
  }

  /**
   * incident_logs updateManyAndReturn
   */
  export type incident_logsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * The data used to update incident_logs.
     */
    data: XOR<incident_logsUpdateManyMutationInput, incident_logsUncheckedUpdateManyInput>
    /**
     * Filter which incident_logs to update
     */
    where?: incident_logsWhereInput
    /**
     * Limit how many incident_logs to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * incident_logs upsert
   */
  export type incident_logsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * The filter to search for the incident_logs to update in case it exists.
     */
    where: incident_logsWhereUniqueInput
    /**
     * In case the incident_logs found by the `where` argument doesn't exist, create a new incident_logs with this data.
     */
    create: XOR<incident_logsCreateInput, incident_logsUncheckedCreateInput>
    /**
     * In case the incident_logs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<incident_logsUpdateInput, incident_logsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * incident_logs delete
   */
  export type incident_logsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    /**
     * Filter which incident_logs to delete.
     */
    where: incident_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * incident_logs.evidence
   */
  export type incident_logs$evidenceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    where?: evidenceWhereInput
    orderBy?: evidenceOrderByWithRelationInput | evidenceOrderByWithRelationInput[]
    cursor?: evidenceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EvidenceScalarFieldEnum | EvidenceScalarFieldEnum[]
  }

  /**
   * incident_logs.panic_button_logs
   */
  export type incident_logs$panic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    where?: panic_button_logsWhereInput
    orderBy?: panic_button_logsOrderByWithRelationInput | panic_button_logsOrderByWithRelationInput[]
    cursor?: panic_button_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Panic_button_logsScalarFieldEnum | Panic_button_logsScalarFieldEnum[]
  }

  /**
   * incident_logs.timelines
   */
  export type incident_logs$timelinesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    where?: timelinesWhereInput
    orderBy?: timelinesOrderByWithRelationInput | timelinesOrderByWithRelationInput[]
    cursor?: timelinesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TimelinesScalarFieldEnum | TimelinesScalarFieldEnum[]
  }

  /**
   * incident_logs.witnesses
   */
  export type incident_logs$witnessesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    where?: witnessesWhereInput
    orderBy?: witnessesOrderByWithRelationInput | witnessesOrderByWithRelationInput[]
    cursor?: witnessesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WitnessesScalarFieldEnum | WitnessesScalarFieldEnum[]
  }

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


  /**
   * Model timelines
   */

  export type AggregateTimelines = {
    _count: TimelinesCountAggregateOutputType | null
    _min: TimelinesMinAggregateOutputType | null
    _max: TimelinesMaxAggregateOutputType | null
  }

  export type TimelinesMinAggregateOutputType = {
    id: string | null
    incident_logs_id: string | null
    crime_incidents_id: string | null
    user_id: string | null
    title: string | null
    description: string | null
    timestamp: Date | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TimelinesMaxAggregateOutputType = {
    id: string | null
    incident_logs_id: string | null
    crime_incidents_id: string | null
    user_id: string | null
    title: string | null
    description: string | null
    timestamp: Date | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TimelinesCountAggregateOutputType = {
    id: number
    incident_logs_id: number
    crime_incidents_id: number
    user_id: number
    title: number
    description: number
    timestamp: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type TimelinesMinAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    user_id?: true
    title?: true
    description?: true
    timestamp?: true
    created_at?: true
    updated_at?: true
  }

  export type TimelinesMaxAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    user_id?: true
    title?: true
    description?: true
    timestamp?: true
    created_at?: true
    updated_at?: true
  }

  export type TimelinesCountAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    user_id?: true
    title?: true
    description?: true
    timestamp?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type timelinesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: timelinesWhereInput
    orderBy?: timelinesOrderByWithAggregationInput | timelinesOrderByWithAggregationInput[]
    by: TimelinesScalarFieldEnum[] | TimelinesScalarFieldEnum
    having?: timelinesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TimelinesCountAggregateInputType | true
    _min?: TimelinesMinAggregateInputType
    _max?: TimelinesMaxAggregateInputType
  }

  export type TimelinesGroupByOutputType = {
    id: string
    incident_logs_id: string | null
    crime_incidents_id: string | null
    user_id: string | null
    title: string | null
    description: string | null
    timestamp: Date
    created_at: Date | null
    updated_at: Date | null
    _count: TimelinesCountAggregateOutputType | null
    _min: TimelinesMinAggregateOutputType | null
    _max: TimelinesMaxAggregateOutputType | null
  }

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


  export type timelinesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    user_id?: boolean
    title?: boolean
    description?: boolean
    timestamp?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }, ExtArgs["result"]["timelines"]>

  export type timelinesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    user_id?: boolean
    title?: boolean
    description?: boolean
    timestamp?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }, ExtArgs["result"]["timelines"]>

  export type timelinesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    user_id?: boolean
    title?: boolean
    description?: boolean
    timestamp?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }, ExtArgs["result"]["timelines"]>

  export type timelinesSelectScalar = {
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    user_id?: boolean
    title?: boolean
    description?: boolean
    timestamp?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type timelinesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "incident_logs_id" | "crime_incidents_id" | "user_id" | "title" | "description" | "timestamp" | "created_at" | "updated_at", ExtArgs["result"]["timelines"]>
  export type timelinesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }
  export type timelinesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }
  export type timelinesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | timelines$crime_incidentsArgs<ExtArgs>
    incident?: boolean | timelines$incidentArgs<ExtArgs>
    user?: boolean | timelines$userArgs<ExtArgs>
  }

  export type $timelinesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "timelines"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs> | null
      incident: Prisma.$incident_logsPayload<ExtArgs> | null
      user: Prisma.$usersPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      incident_logs_id: string | null
      crime_incidents_id: string | null
      user_id: string | null
      title: string | null
      description: string | null
      timestamp: Date
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["timelines"]>
    composites: {}
  }

  type timelinesGetPayload<S extends boolean | null | undefined | timelinesDefaultArgs> = $Result.GetResult<Prisma.$timelinesPayload, S>

  type timelinesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<timelinesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: TimelinesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Timelines.
     * @param {timelinesCreateArgs} args - Arguments to create a Timelines.
     * @example
     * // Create one Timelines
     * const Timelines = await prisma.timelines.create({
     *   data: {
     *     // ... data to create a Timelines
     *   }
     * })
     * 
     */
    create<T extends timelinesCreateArgs>(args: SelectSubset<T, timelinesCreateArgs<ExtArgs>>): Prisma__timelinesClient<$Result.GetResult<Prisma.$timelinesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Timelines.
     * @param {timelinesDeleteArgs} args - Arguments to delete one Timelines.
     * @example
     * // Delete one Timelines
     * const Timelines = await prisma.timelines.delete({
     *   where: {
     *     // ... filter to delete one Timelines
     *   }
     * })
     * 
     */
    delete<T extends timelinesDeleteArgs>(args: SelectSubset<T, timelinesDeleteArgs<ExtArgs>>): Prisma__timelinesClient<$Result.GetResult<Prisma.$timelinesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the timelines model
   */
  interface timelinesFieldRefs {
    readonly id: FieldRef<"timelines", 'String'>
    readonly incident_logs_id: FieldRef<"timelines", 'String'>
    readonly crime_incidents_id: FieldRef<"timelines", 'String'>
    readonly user_id: FieldRef<"timelines", 'String'>
    readonly title: FieldRef<"timelines", 'String'>
    readonly description: FieldRef<"timelines", 'String'>
    readonly timestamp: FieldRef<"timelines", 'DateTime'>
    readonly created_at: FieldRef<"timelines", 'DateTime'>
    readonly updated_at: FieldRef<"timelines", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * timelines findUnique
   */
  export type timelinesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * Filter, which timelines to fetch.
     */
    where: timelinesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * timelines findUniqueOrThrow
   */
  export type timelinesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * Filter, which timelines to fetch.
     */
    where: timelinesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * timelines findMany
   */
  export type timelinesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * Filter, which timelines to fetch.
     */
    where?: timelinesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of timelines to fetch.
     */
    orderBy?: timelinesOrderByWithRelationInput | timelinesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing timelines.
     */
    cursor?: timelinesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` timelines from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` timelines.
     */
    skip?: number
    distinct?: TimelinesScalarFieldEnum | TimelinesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * timelines create
   */
  export type timelinesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * The data needed to create a timelines.
     */
    data?: XOR<timelinesCreateInput, timelinesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * timelines update
   */
  export type timelinesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * The data needed to update a timelines.
     */
    data: XOR<timelinesUpdateInput, timelinesUncheckedUpdateInput>
    /**
     * Choose, which timelines to update.
     */
    where: timelinesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * timelines updateMany
   */
  export type timelinesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update timelines.
     */
    data: XOR<timelinesUpdateManyMutationInput, timelinesUncheckedUpdateManyInput>
    /**
     * Filter which timelines to update
     */
    where?: timelinesWhereInput
    /**
     * Limit how many timelines to update.
     */
    limit?: number
  }

  /**
   * timelines updateManyAndReturn
   */
  export type timelinesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * The data used to update timelines.
     */
    data: XOR<timelinesUpdateManyMutationInput, timelinesUncheckedUpdateManyInput>
    /**
     * Filter which timelines to update
     */
    where?: timelinesWhereInput
    /**
     * Limit how many timelines to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * timelines upsert
   */
  export type timelinesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * The filter to search for the timelines to update in case it exists.
     */
    where: timelinesWhereUniqueInput
    /**
     * In case the timelines found by the `where` argument doesn't exist, create a new timelines with this data.
     */
    create: XOR<timelinesCreateInput, timelinesUncheckedCreateInput>
    /**
     * In case the timelines was found with the provided `where` argument, update it with this data.
     */
    update: XOR<timelinesUpdateInput, timelinesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * timelines delete
   */
  export type timelinesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the timelines
     */
    select?: timelinesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the timelines
     */
    omit?: timelinesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: timelinesInclude<ExtArgs> | null
    /**
     * Filter which timelines to delete.
     */
    where: timelinesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * timelines.crime_incidents
   */
  export type timelines$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
  }

  /**
   * timelines.incident
   */
  export type timelines$incidentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
  }

  /**
   * timelines.user
   */
  export type timelines$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    where?: usersWhereInput
  }

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


  /**
   * Model witnesses
   */

  export type AggregateWitnesses = {
    _count: WitnessesCountAggregateOutputType | null
    _min: WitnessesMinAggregateOutputType | null
    _max: WitnessesMaxAggregateOutputType | null
  }

  export type WitnessesMinAggregateOutputType = {
    id: string | null
    incident_logs_id: string | null
    crime_incidents_id: string | null
    name: string | null
    contact_info: string | null
    statement: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type WitnessesMaxAggregateOutputType = {
    id: string | null
    incident_logs_id: string | null
    crime_incidents_id: string | null
    name: string | null
    contact_info: string | null
    statement: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type WitnessesCountAggregateOutputType = {
    id: number
    incident_logs_id: number
    crime_incidents_id: number
    name: number
    contact_info: number
    statement: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type WitnessesMinAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    name?: true
    contact_info?: true
    statement?: true
    created_at?: true
    updated_at?: true
  }

  export type WitnessesMaxAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    name?: true
    contact_info?: true
    statement?: true
    created_at?: true
    updated_at?: true
  }

  export type WitnessesCountAggregateInputType = {
    id?: true
    incident_logs_id?: true
    crime_incidents_id?: true
    name?: true
    contact_info?: true
    statement?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type witnessesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: witnessesWhereInput
    orderBy?: witnessesOrderByWithAggregationInput | witnessesOrderByWithAggregationInput[]
    by: WitnessesScalarFieldEnum[] | WitnessesScalarFieldEnum
    having?: witnessesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WitnessesCountAggregateInputType | true
    _min?: WitnessesMinAggregateInputType
    _max?: WitnessesMaxAggregateInputType
  }

  export type WitnessesGroupByOutputType = {
    id: string
    incident_logs_id: string | null
    crime_incidents_id: string | null
    name: string | null
    contact_info: string | null
    statement: string | null
    created_at: Date | null
    updated_at: Date | null
    _count: WitnessesCountAggregateOutputType | null
    _min: WitnessesMinAggregateOutputType | null
    _max: WitnessesMaxAggregateOutputType | null
  }

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


  export type witnessesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    name?: boolean
    contact_info?: boolean
    statement?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["witnesses"]>

  export type witnessesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    name?: boolean
    contact_info?: boolean
    statement?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["witnesses"]>

  export type witnessesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    name?: boolean
    contact_info?: boolean
    statement?: boolean
    created_at?: boolean
    updated_at?: boolean
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["witnesses"]>

  export type witnessesSelectScalar = {
    id?: boolean
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    name?: boolean
    contact_info?: boolean
    statement?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type witnessesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "incident_logs_id" | "crime_incidents_id" | "name" | "contact_info" | "statement" | "created_at" | "updated_at", ExtArgs["result"]["witnesses"]>
  export type witnessesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }
  export type witnessesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }
  export type witnessesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | witnesses$crime_incidentsArgs<ExtArgs>
    incident?: boolean | witnesses$incidentArgs<ExtArgs>
  }

  export type $witnessesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "witnesses"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs> | null
      incident: Prisma.$incident_logsPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      incident_logs_id: string | null
      crime_incidents_id: string | null
      name: string | null
      contact_info: string | null
      statement: string | null
      created_at: Date | null
      updated_at: Date | null
    }, ExtArgs["result"]["witnesses"]>
    composites: {}
  }

  type witnessesGetPayload<S extends boolean | null | undefined | witnessesDefaultArgs> = $Result.GetResult<Prisma.$witnessesPayload, S>

  type witnessesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<witnessesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: WitnessesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Witnesses.
     * @param {witnessesCreateArgs} args - Arguments to create a Witnesses.
     * @example
     * // Create one Witnesses
     * const Witnesses = await prisma.witnesses.create({
     *   data: {
     *     // ... data to create a Witnesses
     *   }
     * })
     * 
     */
    create<T extends witnessesCreateArgs>(args: SelectSubset<T, witnessesCreateArgs<ExtArgs>>): Prisma__witnessesClient<$Result.GetResult<Prisma.$witnessesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Witnesses.
     * @param {witnessesDeleteArgs} args - Arguments to delete one Witnesses.
     * @example
     * // Delete one Witnesses
     * const Witnesses = await prisma.witnesses.delete({
     *   where: {
     *     // ... filter to delete one Witnesses
     *   }
     * })
     * 
     */
    delete<T extends witnessesDeleteArgs>(args: SelectSubset<T, witnessesDeleteArgs<ExtArgs>>): Prisma__witnessesClient<$Result.GetResult<Prisma.$witnessesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the witnesses model
   */
  interface witnessesFieldRefs {
    readonly id: FieldRef<"witnesses", 'String'>
    readonly incident_logs_id: FieldRef<"witnesses", 'String'>
    readonly crime_incidents_id: FieldRef<"witnesses", 'String'>
    readonly name: FieldRef<"witnesses", 'String'>
    readonly contact_info: FieldRef<"witnesses", 'String'>
    readonly statement: FieldRef<"witnesses", 'String'>
    readonly created_at: FieldRef<"witnesses", 'DateTime'>
    readonly updated_at: FieldRef<"witnesses", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * witnesses findUnique
   */
  export type witnessesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * Filter, which witnesses to fetch.
     */
    where: witnessesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * witnesses findUniqueOrThrow
   */
  export type witnessesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * Filter, which witnesses to fetch.
     */
    where: witnessesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * witnesses findMany
   */
  export type witnessesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * Filter, which witnesses to fetch.
     */
    where?: witnessesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of witnesses to fetch.
     */
    orderBy?: witnessesOrderByWithRelationInput | witnessesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing witnesses.
     */
    cursor?: witnessesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` witnesses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` witnesses.
     */
    skip?: number
    distinct?: WitnessesScalarFieldEnum | WitnessesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * witnesses create
   */
  export type witnessesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * The data needed to create a witnesses.
     */
    data?: XOR<witnessesCreateInput, witnessesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * witnesses update
   */
  export type witnessesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * The data needed to update a witnesses.
     */
    data: XOR<witnessesUpdateInput, witnessesUncheckedUpdateInput>
    /**
     * Choose, which witnesses to update.
     */
    where: witnessesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * witnesses updateMany
   */
  export type witnessesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update witnesses.
     */
    data: XOR<witnessesUpdateManyMutationInput, witnessesUncheckedUpdateManyInput>
    /**
     * Filter which witnesses to update
     */
    where?: witnessesWhereInput
    /**
     * Limit how many witnesses to update.
     */
    limit?: number
  }

  /**
   * witnesses updateManyAndReturn
   */
  export type witnessesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * The data used to update witnesses.
     */
    data: XOR<witnessesUpdateManyMutationInput, witnessesUncheckedUpdateManyInput>
    /**
     * Filter which witnesses to update
     */
    where?: witnessesWhereInput
    /**
     * Limit how many witnesses to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * witnesses upsert
   */
  export type witnessesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * The filter to search for the witnesses to update in case it exists.
     */
    where: witnessesWhereUniqueInput
    /**
     * In case the witnesses found by the `where` argument doesn't exist, create a new witnesses with this data.
     */
    create: XOR<witnessesCreateInput, witnessesUncheckedCreateInput>
    /**
     * In case the witnesses was found with the provided `where` argument, update it with this data.
     */
    update: XOR<witnessesUpdateInput, witnessesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * witnesses delete
   */
  export type witnessesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the witnesses
     */
    select?: witnessesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the witnesses
     */
    omit?: witnessesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: witnessesInclude<ExtArgs> | null
    /**
     * Filter which witnesses to delete.
     */
    where: witnessesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * witnesses.crime_incidents
   */
  export type witnesses$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
  }

  /**
   * witnesses.incident
   */
  export type witnesses$incidentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
  }

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


  /**
   * Model evidence
   */

  export type AggregateEvidence = {
    _count: EvidenceCountAggregateOutputType | null
    _min: EvidenceMinAggregateOutputType | null
    _max: EvidenceMaxAggregateOutputType | null
  }

  export type EvidenceMinAggregateOutputType = {
    incident_logs_id: string | null
    crime_incidents_id: string | null
    type: string | null
    url: string | null
    status: string | null
    uploaded_at: Date | null
    updated_at: Date | null
    caption: string | null
    description: string | null
    id: string | null
  }

  export type EvidenceMaxAggregateOutputType = {
    incident_logs_id: string | null
    crime_incidents_id: string | null
    type: string | null
    url: string | null
    status: string | null
    uploaded_at: Date | null
    updated_at: Date | null
    caption: string | null
    description: string | null
    id: string | null
  }

  export type EvidenceCountAggregateOutputType = {
    incident_logs_id: number
    crime_incidents_id: number
    type: number
    url: number
    status: number
    uploaded_at: number
    updated_at: number
    caption: number
    description: number
    metadata: number
    id: number
    _all: number
  }


  export type EvidenceMinAggregateInputType = {
    incident_logs_id?: true
    crime_incidents_id?: true
    type?: true
    url?: true
    status?: true
    uploaded_at?: true
    updated_at?: true
    caption?: true
    description?: true
    id?: true
  }

  export type EvidenceMaxAggregateInputType = {
    incident_logs_id?: true
    crime_incidents_id?: true
    type?: true
    url?: true
    status?: true
    uploaded_at?: true
    updated_at?: true
    caption?: true
    description?: true
    id?: true
  }

  export type EvidenceCountAggregateInputType = {
    incident_logs_id?: true
    crime_incidents_id?: true
    type?: true
    url?: true
    status?: true
    uploaded_at?: true
    updated_at?: true
    caption?: true
    description?: true
    metadata?: true
    id?: true
    _all?: true
  }

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

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




  export type evidenceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: evidenceWhereInput
    orderBy?: evidenceOrderByWithAggregationInput | evidenceOrderByWithAggregationInput[]
    by: EvidenceScalarFieldEnum[] | EvidenceScalarFieldEnum
    having?: evidenceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EvidenceCountAggregateInputType | true
    _min?: EvidenceMinAggregateInputType
    _max?: EvidenceMaxAggregateInputType
  }

  export type EvidenceGroupByOutputType = {
    incident_logs_id: string | null
    crime_incidents_id: string | null
    type: string
    url: string
    status: string | null
    uploaded_at: Date | null
    updated_at: Date | null
    caption: string | null
    description: string | null
    metadata: JsonValue | null
    id: string
    _count: EvidenceCountAggregateOutputType | null
    _min: EvidenceMinAggregateOutputType | null
    _max: EvidenceMaxAggregateOutputType | null
  }

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


  export type evidenceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    type?: boolean
    url?: boolean
    status?: boolean
    uploaded_at?: boolean
    updated_at?: boolean
    caption?: boolean
    description?: boolean
    metadata?: boolean
    id?: boolean
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["evidence"]>

  export type evidenceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    type?: boolean
    url?: boolean
    status?: boolean
    uploaded_at?: boolean
    updated_at?: boolean
    caption?: boolean
    description?: boolean
    metadata?: boolean
    id?: boolean
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["evidence"]>

  export type evidenceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    type?: boolean
    url?: boolean
    status?: boolean
    uploaded_at?: boolean
    updated_at?: boolean
    caption?: boolean
    description?: boolean
    metadata?: boolean
    id?: boolean
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }, ExtArgs["result"]["evidence"]>

  export type evidenceSelectScalar = {
    incident_logs_id?: boolean
    crime_incidents_id?: boolean
    type?: boolean
    url?: boolean
    status?: boolean
    uploaded_at?: boolean
    updated_at?: boolean
    caption?: boolean
    description?: boolean
    metadata?: boolean
    id?: boolean
  }

  export type evidenceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"incident_logs_id" | "crime_incidents_id" | "type" | "url" | "status" | "uploaded_at" | "updated_at" | "caption" | "description" | "metadata" | "id", ExtArgs["result"]["evidence"]>
  export type evidenceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }
  export type evidenceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }
  export type evidenceIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    crime_incidents?: boolean | evidence$crime_incidentsArgs<ExtArgs>
    incident?: boolean | evidence$incidentArgs<ExtArgs>
  }

  export type $evidencePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "evidence"
    objects: {
      crime_incidents: Prisma.$crime_incidentsPayload<ExtArgs> | null
      incident: Prisma.$incident_logsPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      incident_logs_id: string | null
      crime_incidents_id: string | null
      type: string
      url: string
      status: string | null
      uploaded_at: Date | null
      updated_at: Date | null
      caption: string | null
      description: string | null
      metadata: Prisma.JsonValue | null
      id: string
    }, ExtArgs["result"]["evidence"]>
    composites: {}
  }

  type evidenceGetPayload<S extends boolean | null | undefined | evidenceDefaultArgs> = $Result.GetResult<Prisma.$evidencePayload, S>

  type evidenceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<evidenceFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: EvidenceCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Evidence.
     * @param {evidenceCreateArgs} args - Arguments to create a Evidence.
     * @example
     * // Create one Evidence
     * const Evidence = await prisma.evidence.create({
     *   data: {
     *     // ... data to create a Evidence
     *   }
     * })
     * 
     */
    create<T extends evidenceCreateArgs>(args: SelectSubset<T, evidenceCreateArgs<ExtArgs>>): Prisma__evidenceClient<$Result.GetResult<Prisma.$evidencePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Evidence.
     * @param {evidenceDeleteArgs} args - Arguments to delete one Evidence.
     * @example
     * // Delete one Evidence
     * const Evidence = await prisma.evidence.delete({
     *   where: {
     *     // ... filter to delete one Evidence
     *   }
     * })
     * 
     */
    delete<T extends evidenceDeleteArgs>(args: SelectSubset<T, evidenceDeleteArgs<ExtArgs>>): Prisma__evidenceClient<$Result.GetResult<Prisma.$evidencePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the evidence model
   */
  interface evidenceFieldRefs {
    readonly incident_logs_id: FieldRef<"evidence", 'String'>
    readonly crime_incidents_id: FieldRef<"evidence", 'String'>
    readonly type: FieldRef<"evidence", 'String'>
    readonly url: FieldRef<"evidence", 'String'>
    readonly status: FieldRef<"evidence", 'String'>
    readonly uploaded_at: FieldRef<"evidence", 'DateTime'>
    readonly updated_at: FieldRef<"evidence", 'DateTime'>
    readonly caption: FieldRef<"evidence", 'String'>
    readonly description: FieldRef<"evidence", 'String'>
    readonly metadata: FieldRef<"evidence", 'Json'>
    readonly id: FieldRef<"evidence", 'String'>
  }
    

  // Custom InputTypes
  /**
   * evidence findUnique
   */
  export type evidenceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter, which evidence to fetch.
     */
    where: evidenceWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence findUniqueOrThrow
   */
  export type evidenceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter, which evidence to fetch.
     */
    where: evidenceWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence findFirst
   */
  export type evidenceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter, which evidence to fetch.
     */
    where?: evidenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of evidences to fetch.
     */
    orderBy?: evidenceOrderByWithRelationInput | evidenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for evidences.
     */
    cursor?: evidenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` evidences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` evidences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of evidences.
     */
    distinct?: EvidenceScalarFieldEnum | EvidenceScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence findFirstOrThrow
   */
  export type evidenceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter, which evidence to fetch.
     */
    where?: evidenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of evidences to fetch.
     */
    orderBy?: evidenceOrderByWithRelationInput | evidenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for evidences.
     */
    cursor?: evidenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` evidences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` evidences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of evidences.
     */
    distinct?: EvidenceScalarFieldEnum | EvidenceScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence findMany
   */
  export type evidenceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter, which evidences to fetch.
     */
    where?: evidenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of evidences to fetch.
     */
    orderBy?: evidenceOrderByWithRelationInput | evidenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing evidences.
     */
    cursor?: evidenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` evidences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` evidences.
     */
    skip?: number
    distinct?: EvidenceScalarFieldEnum | EvidenceScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence create
   */
  export type evidenceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * The data needed to create a evidence.
     */
    data: XOR<evidenceCreateInput, evidenceUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * evidence createManyAndReturn
   */
  export type evidenceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * The data used to create many evidences.
     */
    data: evidenceCreateManyInput | evidenceCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * evidence update
   */
  export type evidenceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * The data needed to update a evidence.
     */
    data: XOR<evidenceUpdateInput, evidenceUncheckedUpdateInput>
    /**
     * Choose, which evidence to update.
     */
    where: evidenceWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence updateMany
   */
  export type evidenceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update evidences.
     */
    data: XOR<evidenceUpdateManyMutationInput, evidenceUncheckedUpdateManyInput>
    /**
     * Filter which evidences to update
     */
    where?: evidenceWhereInput
    /**
     * Limit how many evidences to update.
     */
    limit?: number
  }

  /**
   * evidence updateManyAndReturn
   */
  export type evidenceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * The data used to update evidences.
     */
    data: XOR<evidenceUpdateManyMutationInput, evidenceUncheckedUpdateManyInput>
    /**
     * Filter which evidences to update
     */
    where?: evidenceWhereInput
    /**
     * Limit how many evidences to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * evidence upsert
   */
  export type evidenceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * The filter to search for the evidence to update in case it exists.
     */
    where: evidenceWhereUniqueInput
    /**
     * In case the evidence found by the `where` argument doesn't exist, create a new evidence with this data.
     */
    create: XOR<evidenceCreateInput, evidenceUncheckedCreateInput>
    /**
     * In case the evidence was found with the provided `where` argument, update it with this data.
     */
    update: XOR<evidenceUpdateInput, evidenceUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * evidence delete
   */
  export type evidenceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the evidence
     */
    select?: evidenceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the evidence
     */
    omit?: evidenceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: evidenceInclude<ExtArgs> | null
    /**
     * Filter which evidence to delete.
     */
    where: evidenceWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * evidence.crime_incidents
   */
  export type evidence$crime_incidentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the crime_incidents
     */
    select?: crime_incidentsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the crime_incidents
     */
    omit?: crime_incidentsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: crime_incidentsInclude<ExtArgs> | null
    where?: crime_incidentsWhereInput
  }

  /**
   * evidence.incident
   */
  export type evidence$incidentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the incident_logs
     */
    select?: incident_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the incident_logs
     */
    omit?: incident_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: incident_logsInclude<ExtArgs> | null
    where?: incident_logsWhereInput
  }

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


  /**
   * Model units
   */

  export type AggregateUnits = {
    _count: UnitsCountAggregateOutputType | null
    _avg: UnitsAvgAggregateOutputType | null
    _sum: UnitsSumAggregateOutputType | null
    _min: UnitsMinAggregateOutputType | null
    _max: UnitsMaxAggregateOutputType | null
  }

  export type UnitsAvgAggregateOutputType = {
    land_area: number | null
    latitude: number | null
    longitude: number | null
  }

  export type UnitsSumAggregateOutputType = {
    land_area: number | null
    latitude: number | null
    longitude: number | null
  }

  export type UnitsMinAggregateOutputType = {
    code_unit: string | null
    district_id: string | null
    name: string | null
    description: string | null
    type: $Enums.unit_type | null
    created_at: Date | null
    updated_at: Date | null
    address: string | null
    land_area: number | null
    latitude: number | null
    longitude: number | null
    city_id: string | null
    phone: string | null
  }

  export type UnitsMaxAggregateOutputType = {
    code_unit: string | null
    district_id: string | null
    name: string | null
    description: string | null
    type: $Enums.unit_type | null
    created_at: Date | null
    updated_at: Date | null
    address: string | null
    land_area: number | null
    latitude: number | null
    longitude: number | null
    city_id: string | null
    phone: string | null
  }

  export type UnitsCountAggregateOutputType = {
    code_unit: number
    district_id: number
    name: number
    description: number
    type: number
    created_at: number
    updated_at: number
    address: number
    land_area: number
    latitude: number
    longitude: number
    city_id: number
    phone: number
    _all: number
  }


  export type UnitsAvgAggregateInputType = {
    land_area?: true
    latitude?: true
    longitude?: true
  }

  export type UnitsSumAggregateInputType = {
    land_area?: true
    latitude?: true
    longitude?: true
  }

  export type UnitsMinAggregateInputType = {
    code_unit?: true
    district_id?: true
    name?: true
    description?: true
    type?: true
    created_at?: true
    updated_at?: true
    address?: true
    land_area?: true
    latitude?: true
    longitude?: true
    city_id?: true
    phone?: true
  }

  export type UnitsMaxAggregateInputType = {
    code_unit?: true
    district_id?: true
    name?: true
    description?: true
    type?: true
    created_at?: true
    updated_at?: true
    address?: true
    land_area?: true
    latitude?: true
    longitude?: true
    city_id?: true
    phone?: true
  }

  export type UnitsCountAggregateInputType = {
    code_unit?: true
    district_id?: true
    name?: true
    description?: true
    type?: true
    created_at?: true
    updated_at?: true
    address?: true
    land_area?: true
    latitude?: true
    longitude?: true
    city_id?: true
    phone?: true
    _all?: true
  }

  export type UnitsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which units to aggregate.
     */
    where?: unitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of units to fetch.
     */
    orderBy?: unitsOrderByWithRelationInput | unitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: unitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` units from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` units.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned units
    **/
    _count?: true | UnitsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UnitsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UnitsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UnitsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UnitsMaxAggregateInputType
  }

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




  export type unitsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: unitsWhereInput
    orderBy?: unitsOrderByWithAggregationInput | unitsOrderByWithAggregationInput[]
    by: UnitsScalarFieldEnum[] | UnitsScalarFieldEnum
    having?: unitsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UnitsCountAggregateInputType | true
    _avg?: UnitsAvgAggregateInputType
    _sum?: UnitsSumAggregateInputType
    _min?: UnitsMinAggregateInputType
    _max?: UnitsMaxAggregateInputType
  }

  export type UnitsGroupByOutputType = {
    code_unit: string
    district_id: string | null
    name: string
    description: string | null
    type: $Enums.unit_type
    created_at: Date | null
    updated_at: Date | null
    address: string | null
    land_area: number | null
    latitude: number
    longitude: number
    city_id: string
    phone: string | null
    _count: UnitsCountAggregateOutputType | null
    _avg: UnitsAvgAggregateOutputType | null
    _sum: UnitsSumAggregateOutputType | null
    _min: UnitsMinAggregateOutputType | null
    _max: UnitsMaxAggregateOutputType | null
  }

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


  export type unitsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    code_unit?: boolean
    district_id?: boolean
    name?: boolean
    description?: boolean
    type?: boolean
    created_at?: boolean
    updated_at?: boolean
    address?: boolean
    land_area?: boolean
    latitude?: boolean
    longitude?: boolean
    city_id?: boolean
    phone?: boolean
    officers?: boolean | units$officersArgs<ExtArgs>
    patrol_units?: boolean | units$patrol_unitsArgs<ExtArgs>
    unit_statistics?: boolean | units$unit_statisticsArgs<ExtArgs>
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    districts?: boolean | units$districtsArgs<ExtArgs>
    _count?: boolean | UnitsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["units"]>


  export type unitsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    code_unit?: boolean
    district_id?: boolean
    name?: boolean
    description?: boolean
    type?: boolean
    created_at?: boolean
    updated_at?: boolean
    address?: boolean
    land_area?: boolean
    latitude?: boolean
    longitude?: boolean
    city_id?: boolean
    phone?: boolean
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    districts?: boolean | units$districtsArgs<ExtArgs>
  }, ExtArgs["result"]["units"]>

  export type unitsSelectScalar = {
    code_unit?: boolean
    district_id?: boolean
    name?: boolean
    description?: boolean
    type?: boolean
    created_at?: boolean
    updated_at?: boolean
    address?: boolean
    land_area?: boolean
    latitude?: boolean
    longitude?: boolean
    city_id?: boolean
    phone?: boolean
  }

  export type unitsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"code_unit" | "district_id" | "name" | "description" | "type" | "created_at" | "updated_at" | "address" | "land_area" | "latitude" | "longitude" | "city_id" | "phone", ExtArgs["result"]["units"]>
  export type unitsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    officers?: boolean | units$officersArgs<ExtArgs>
    patrol_units?: boolean | units$patrol_unitsArgs<ExtArgs>
    unit_statistics?: boolean | units$unit_statisticsArgs<ExtArgs>
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    districts?: boolean | units$districtsArgs<ExtArgs>
    _count?: boolean | UnitsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type unitsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    cities?: boolean | citiesDefaultArgs<ExtArgs>
    districts?: boolean | units$districtsArgs<ExtArgs>
  }

  export type $unitsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "units"
    objects: {
      officers: Prisma.$officersPayload<ExtArgs>[]
      patrol_units: Prisma.$patrol_unitsPayload<ExtArgs>[]
      unit_statistics: Prisma.$unit_statisticsPayload<ExtArgs>[]
      cities: Prisma.$citiesPayload<ExtArgs>
      districts: Prisma.$districtsPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      code_unit: string
      district_id: string | null
      name: string
      description: string | null
      type: $Enums.unit_type
      created_at: Date | null
      updated_at: Date | null
      address: string | null
      land_area: number | null
      latitude: number
      longitude: number
      city_id: string
      phone: string | null
    }, ExtArgs["result"]["units"]>
    composites: {}
  }

  type unitsGetPayload<S extends boolean | null | undefined | unitsDefaultArgs> = $Result.GetResult<Prisma.$unitsPayload, S>

  type unitsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<unitsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: UnitsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Delete a Units.
     * @param {unitsDeleteArgs} args - Arguments to delete one Units.
     * @example
     * // Delete one Units
     * const Units = await prisma.units.delete({
     *   where: {
     *     // ... filter to delete one Units
     *   }
     * })
     * 
     */
    delete<T extends unitsDeleteArgs>(args: SelectSubset<T, unitsDeleteArgs<ExtArgs>>): Prisma__unitsClient<$Result.GetResult<Prisma.$unitsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for units.
   * 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__unitsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    officers<T extends units$officersArgs<ExtArgs> = {}>(args?: Subset<T, units$officersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$officersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    patrol_units<T extends units$patrol_unitsArgs<ExtArgs> = {}>(args?: Subset<T, units$patrol_unitsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$patrol_unitsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    unit_statistics<T extends units$unit_statisticsArgs<ExtArgs> = {}>(args?: Subset<T, units$unit_statisticsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$unit_statisticsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    cities<T extends citiesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, citiesDefaultArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    districts<T extends units$districtsArgs<ExtArgs> = {}>(args?: Subset<T, units$districtsArgs<ExtArgs>>): Prisma__districtsClient<$Result.GetResult<Prisma.$districtsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the units model
   */
  interface unitsFieldRefs {
    readonly code_unit: FieldRef<"units", 'String'>
    readonly district_id: FieldRef<"units", 'String'>
    readonly name: FieldRef<"units", 'String'>
    readonly description: FieldRef<"units", 'String'>
    readonly type: FieldRef<"units", 'unit_type'>
    readonly created_at: FieldRef<"units", 'DateTime'>
    readonly updated_at: FieldRef<"units", 'DateTime'>
    readonly address: FieldRef<"units", 'String'>
    readonly land_area: FieldRef<"units", 'Float'>
    readonly latitude: FieldRef<"units", 'Float'>
    readonly longitude: FieldRef<"units", 'Float'>
    readonly city_id: FieldRef<"units", 'String'>
    readonly phone: FieldRef<"units", 'String'>
  }
    

  // Custom InputTypes
  /**
   * units findUnique
   */
  export type unitsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    /**
     * Filter, which units to fetch.
     */
    where: unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * units findUniqueOrThrow
   */
  export type unitsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    /**
     * Filter, which units to fetch.
     */
    where: unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * units findMany
   */
  export type unitsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    /**
     * Filter, which units to fetch.
     */
    where?: unitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of units to fetch.
     */
    orderBy?: unitsOrderByWithRelationInput | unitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing units.
     */
    cursor?: unitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` units from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` units.
     */
    skip?: number
    distinct?: UnitsScalarFieldEnum | UnitsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * units update
   */
  export type unitsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    /**
     * The data needed to update a units.
     */
    data: XOR<unitsUpdateInput, unitsUncheckedUpdateInput>
    /**
     * Choose, which units to update.
     */
    where: unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * units updateMany
   */
  export type unitsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update units.
     */
    data: XOR<unitsUpdateManyMutationInput, unitsUncheckedUpdateManyInput>
    /**
     * Filter which units to update
     */
    where?: unitsWhereInput
    /**
     * Limit how many units to update.
     */
    limit?: number
  }

  /**
   * units updateManyAndReturn
   */
  export type unitsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * The data used to update units.
     */
    data: XOR<unitsUpdateManyMutationInput, unitsUncheckedUpdateManyInput>
    /**
     * Filter which units to update
     */
    where?: unitsWhereInput
    /**
     * Limit how many units to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * units delete
   */
  export type unitsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    /**
     * Filter which units to delete.
     */
    where: unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * units.officers
   */
  export type units$officersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
    orderBy?: officersOrderByWithRelationInput | officersOrderByWithRelationInput[]
    cursor?: officersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OfficersScalarFieldEnum | OfficersScalarFieldEnum[]
  }

  /**
   * units.patrol_units
   */
  export type units$patrol_unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    where?: patrol_unitsWhereInput
    orderBy?: patrol_unitsOrderByWithRelationInput | patrol_unitsOrderByWithRelationInput[]
    cursor?: patrol_unitsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Patrol_unitsScalarFieldEnum | Patrol_unitsScalarFieldEnum[]
  }

  /**
   * units.unit_statistics
   */
  export type units$unit_statisticsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    where?: unit_statisticsWhereInput
    orderBy?: unit_statisticsOrderByWithRelationInput | unit_statisticsOrderByWithRelationInput[]
    cursor?: unit_statisticsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Unit_statisticsScalarFieldEnum | Unit_statisticsScalarFieldEnum[]
  }

  /**
   * units.districts
   */
  export type units$districtsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the districts
     */
    select?: districtsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the districts
     */
    omit?: districtsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: districtsInclude<ExtArgs> | null
    where?: districtsWhereInput
  }

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


  /**
   * Model patrol_units
   */

  export type AggregatePatrol_units = {
    _count: Patrol_unitsCountAggregateOutputType | null
    _avg: Patrol_unitsAvgAggregateOutputType | null
    _sum: Patrol_unitsSumAggregateOutputType | null
    _min: Patrol_unitsMinAggregateOutputType | null
    _max: Patrol_unitsMaxAggregateOutputType | null
  }

  export type Patrol_unitsAvgAggregateOutputType = {
    radius: number | null
    member_count: number | null
  }

  export type Patrol_unitsSumAggregateOutputType = {
    radius: number | null
    member_count: number | null
  }

  export type Patrol_unitsMinAggregateOutputType = {
    unit_id: string | null
    location_id: string | null
    name: string | null
    type: string | null
    status: string | null
    radius: number | null
    created_at: Date | null
    id: string | null
    category: $Enums.patrol_unit_category | null
    member_count: number | null
    updated_at: Date | null
  }

  export type Patrol_unitsMaxAggregateOutputType = {
    unit_id: string | null
    location_id: string | null
    name: string | null
    type: string | null
    status: string | null
    radius: number | null
    created_at: Date | null
    id: string | null
    category: $Enums.patrol_unit_category | null
    member_count: number | null
    updated_at: Date | null
  }

  export type Patrol_unitsCountAggregateOutputType = {
    unit_id: number
    location_id: number
    name: number
    type: number
    status: number
    radius: number
    created_at: number
    id: number
    category: number
    member_count: number
    updated_at: number
    _all: number
  }


  export type Patrol_unitsAvgAggregateInputType = {
    radius?: true
    member_count?: true
  }

  export type Patrol_unitsSumAggregateInputType = {
    radius?: true
    member_count?: true
  }

  export type Patrol_unitsMinAggregateInputType = {
    unit_id?: true
    location_id?: true
    name?: true
    type?: true
    status?: true
    radius?: true
    created_at?: true
    id?: true
    category?: true
    member_count?: true
    updated_at?: true
  }

  export type Patrol_unitsMaxAggregateInputType = {
    unit_id?: true
    location_id?: true
    name?: true
    type?: true
    status?: true
    radius?: true
    created_at?: true
    id?: true
    category?: true
    member_count?: true
    updated_at?: true
  }

  export type Patrol_unitsCountAggregateInputType = {
    unit_id?: true
    location_id?: true
    name?: true
    type?: true
    status?: true
    radius?: true
    created_at?: true
    id?: true
    category?: true
    member_count?: true
    updated_at?: true
    _all?: true
  }

  export type Patrol_unitsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which patrol_units to aggregate.
     */
    where?: patrol_unitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of patrol_units to fetch.
     */
    orderBy?: patrol_unitsOrderByWithRelationInput | patrol_unitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: patrol_unitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` patrol_units from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` patrol_units.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned patrol_units
    **/
    _count?: true | Patrol_unitsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Patrol_unitsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Patrol_unitsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Patrol_unitsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Patrol_unitsMaxAggregateInputType
  }

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




  export type patrol_unitsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: patrol_unitsWhereInput
    orderBy?: patrol_unitsOrderByWithAggregationInput | patrol_unitsOrderByWithAggregationInput[]
    by: Patrol_unitsScalarFieldEnum[] | Patrol_unitsScalarFieldEnum
    having?: patrol_unitsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Patrol_unitsCountAggregateInputType | true
    _avg?: Patrol_unitsAvgAggregateInputType
    _sum?: Patrol_unitsSumAggregateInputType
    _min?: Patrol_unitsMinAggregateInputType
    _max?: Patrol_unitsMaxAggregateInputType
  }

  export type Patrol_unitsGroupByOutputType = {
    unit_id: string
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at: Date
    id: string
    category: $Enums.patrol_unit_category | null
    member_count: number | null
    updated_at: Date | null
    _count: Patrol_unitsCountAggregateOutputType | null
    _avg: Patrol_unitsAvgAggregateOutputType | null
    _sum: Patrol_unitsSumAggregateOutputType | null
    _min: Patrol_unitsMinAggregateOutputType | null
    _max: Patrol_unitsMaxAggregateOutputType | null
  }

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


  export type patrol_unitsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    location_id?: boolean
    name?: boolean
    type?: boolean
    status?: boolean
    radius?: boolean
    created_at?: boolean
    id?: boolean
    category?: boolean
    member_count?: boolean
    updated_at?: boolean
    members?: boolean | patrol_units$membersArgs<ExtArgs>
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
    _count?: boolean | Patrol_unitsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patrol_units"]>

  export type patrol_unitsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    location_id?: boolean
    name?: boolean
    type?: boolean
    status?: boolean
    radius?: boolean
    created_at?: boolean
    id?: boolean
    category?: boolean
    member_count?: boolean
    updated_at?: boolean
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patrol_units"]>

  export type patrol_unitsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    location_id?: boolean
    name?: boolean
    type?: boolean
    status?: boolean
    radius?: boolean
    created_at?: boolean
    id?: boolean
    category?: boolean
    member_count?: boolean
    updated_at?: boolean
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["patrol_units"]>

  export type patrol_unitsSelectScalar = {
    unit_id?: boolean
    location_id?: boolean
    name?: boolean
    type?: boolean
    status?: boolean
    radius?: boolean
    created_at?: boolean
    id?: boolean
    category?: boolean
    member_count?: boolean
    updated_at?: boolean
  }

  export type patrol_unitsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"unit_id" | "location_id" | "name" | "type" | "status" | "radius" | "created_at" | "id" | "category" | "member_count" | "updated_at", ExtArgs["result"]["patrol_units"]>
  export type patrol_unitsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    members?: boolean | patrol_units$membersArgs<ExtArgs>
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
    _count?: boolean | Patrol_unitsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type patrol_unitsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
  }
  export type patrol_unitsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    location?: boolean | locationsDefaultArgs<ExtArgs>
    unit?: boolean | unitsDefaultArgs<ExtArgs>
  }

  export type $patrol_unitsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "patrol_units"
    objects: {
      members: Prisma.$officersPayload<ExtArgs>[]
      location: Prisma.$locationsPayload<ExtArgs>
      unit: Prisma.$unitsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      unit_id: string
      location_id: string
      name: string
      type: string
      status: string
      radius: number
      created_at: Date
      id: string
      category: $Enums.patrol_unit_category | null
      member_count: number | null
      updated_at: Date | null
    }, ExtArgs["result"]["patrol_units"]>
    composites: {}
  }

  type patrol_unitsGetPayload<S extends boolean | null | undefined | patrol_unitsDefaultArgs> = $Result.GetResult<Prisma.$patrol_unitsPayload, S>

  type patrol_unitsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<patrol_unitsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Patrol_unitsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Patrol_units.
     * @param {patrol_unitsCreateArgs} args - Arguments to create a Patrol_units.
     * @example
     * // Create one Patrol_units
     * const Patrol_units = await prisma.patrol_units.create({
     *   data: {
     *     // ... data to create a Patrol_units
     *   }
     * })
     * 
     */
    create<T extends patrol_unitsCreateArgs>(args: SelectSubset<T, patrol_unitsCreateArgs<ExtArgs>>): Prisma__patrol_unitsClient<$Result.GetResult<Prisma.$patrol_unitsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Patrol_units.
     * @param {patrol_unitsDeleteArgs} args - Arguments to delete one Patrol_units.
     * @example
     * // Delete one Patrol_units
     * const Patrol_units = await prisma.patrol_units.delete({
     *   where: {
     *     // ... filter to delete one Patrol_units
     *   }
     * })
     * 
     */
    delete<T extends patrol_unitsDeleteArgs>(args: SelectSubset<T, patrol_unitsDeleteArgs<ExtArgs>>): Prisma__patrol_unitsClient<$Result.GetResult<Prisma.$patrol_unitsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the patrol_units model
   */
  interface patrol_unitsFieldRefs {
    readonly unit_id: FieldRef<"patrol_units", 'String'>
    readonly location_id: FieldRef<"patrol_units", 'String'>
    readonly name: FieldRef<"patrol_units", 'String'>
    readonly type: FieldRef<"patrol_units", 'String'>
    readonly status: FieldRef<"patrol_units", 'String'>
    readonly radius: FieldRef<"patrol_units", 'Float'>
    readonly created_at: FieldRef<"patrol_units", 'DateTime'>
    readonly id: FieldRef<"patrol_units", 'String'>
    readonly category: FieldRef<"patrol_units", 'patrol_unit_category'>
    readonly member_count: FieldRef<"patrol_units", 'Int'>
    readonly updated_at: FieldRef<"patrol_units", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * patrol_units findUnique
   */
  export type patrol_unitsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * Filter, which patrol_units to fetch.
     */
    where: patrol_unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * patrol_units findUniqueOrThrow
   */
  export type patrol_unitsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * Filter, which patrol_units to fetch.
     */
    where: patrol_unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * patrol_units findMany
   */
  export type patrol_unitsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * Filter, which patrol_units to fetch.
     */
    where?: patrol_unitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of patrol_units to fetch.
     */
    orderBy?: patrol_unitsOrderByWithRelationInput | patrol_unitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing patrol_units.
     */
    cursor?: patrol_unitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` patrol_units from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` patrol_units.
     */
    skip?: number
    distinct?: Patrol_unitsScalarFieldEnum | Patrol_unitsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * patrol_units create
   */
  export type patrol_unitsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * The data needed to create a patrol_units.
     */
    data: XOR<patrol_unitsCreateInput, patrol_unitsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * patrol_units update
   */
  export type patrol_unitsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * The data needed to update a patrol_units.
     */
    data: XOR<patrol_unitsUpdateInput, patrol_unitsUncheckedUpdateInput>
    /**
     * Choose, which patrol_units to update.
     */
    where: patrol_unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * patrol_units updateMany
   */
  export type patrol_unitsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update patrol_units.
     */
    data: XOR<patrol_unitsUpdateManyMutationInput, patrol_unitsUncheckedUpdateManyInput>
    /**
     * Filter which patrol_units to update
     */
    where?: patrol_unitsWhereInput
    /**
     * Limit how many patrol_units to update.
     */
    limit?: number
  }

  /**
   * patrol_units updateManyAndReturn
   */
  export type patrol_unitsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * The data used to update patrol_units.
     */
    data: XOR<patrol_unitsUpdateManyMutationInput, patrol_unitsUncheckedUpdateManyInput>
    /**
     * Filter which patrol_units to update
     */
    where?: patrol_unitsWhereInput
    /**
     * Limit how many patrol_units to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * patrol_units upsert
   */
  export type patrol_unitsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * The filter to search for the patrol_units to update in case it exists.
     */
    where: patrol_unitsWhereUniqueInput
    /**
     * In case the patrol_units found by the `where` argument doesn't exist, create a new patrol_units with this data.
     */
    create: XOR<patrol_unitsCreateInput, patrol_unitsUncheckedCreateInput>
    /**
     * In case the patrol_units was found with the provided `where` argument, update it with this data.
     */
    update: XOR<patrol_unitsUpdateInput, patrol_unitsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * patrol_units delete
   */
  export type patrol_unitsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    /**
     * Filter which patrol_units to delete.
     */
    where: patrol_unitsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * patrol_units.members
   */
  export type patrol_units$membersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
    orderBy?: officersOrderByWithRelationInput | officersOrderByWithRelationInput[]
    cursor?: officersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OfficersScalarFieldEnum | OfficersScalarFieldEnum[]
  }

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


  /**
   * Model officers
   */

  export type AggregateOfficers = {
    _count: OfficersCountAggregateOutputType | null
    _avg: OfficersAvgAggregateOutputType | null
    _sum: OfficersSumAggregateOutputType | null
    _min: OfficersMinAggregateOutputType | null
    _max: OfficersMaxAggregateOutputType | null
  }

  export type OfficersAvgAggregateOutputType = {
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type OfficersSumAggregateOutputType = {
    panic_strike: number | null
    spoofing_attempts: number | null
  }

  export type OfficersMinAggregateOutputType = {
    unit_id: string | null
    role_id: string | null
    nrp: string | null
    name: string | null
    rank: string | null
    position: string | null
    phone: string | null
    email: string | null
    avatar: string | null
    valid_until: Date | null
    qr_code: string | null
    created_at: Date | null
    updated_at: Date | null
    patrol_unit_id: string | null
    id: string | null
    banned_reason: string | null
    banned_until: Date | null
    is_banned: boolean | null
    panic_strike: number | null
    spoofing_attempts: number | null
    place_of_birth: string | null
    date_of_birth: Date | null
  }

  export type OfficersMaxAggregateOutputType = {
    unit_id: string | null
    role_id: string | null
    nrp: string | null
    name: string | null
    rank: string | null
    position: string | null
    phone: string | null
    email: string | null
    avatar: string | null
    valid_until: Date | null
    qr_code: string | null
    created_at: Date | null
    updated_at: Date | null
    patrol_unit_id: string | null
    id: string | null
    banned_reason: string | null
    banned_until: Date | null
    is_banned: boolean | null
    panic_strike: number | null
    spoofing_attempts: number | null
    place_of_birth: string | null
    date_of_birth: Date | null
  }

  export type OfficersCountAggregateOutputType = {
    unit_id: number
    role_id: number
    nrp: number
    name: number
    rank: number
    position: number
    phone: number
    email: number
    avatar: number
    valid_until: number
    qr_code: number
    created_at: number
    updated_at: number
    patrol_unit_id: number
    id: number
    banned_reason: number
    banned_until: number
    is_banned: number
    panic_strike: number
    spoofing_attempts: number
    place_of_birth: number
    date_of_birth: number
    _all: number
  }


  export type OfficersAvgAggregateInputType = {
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type OfficersSumAggregateInputType = {
    panic_strike?: true
    spoofing_attempts?: true
  }

  export type OfficersMinAggregateInputType = {
    unit_id?: true
    role_id?: true
    nrp?: true
    name?: true
    rank?: true
    position?: true
    phone?: true
    email?: true
    avatar?: true
    valid_until?: true
    qr_code?: true
    created_at?: true
    updated_at?: true
    patrol_unit_id?: true
    id?: true
    banned_reason?: true
    banned_until?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
    place_of_birth?: true
    date_of_birth?: true
  }

  export type OfficersMaxAggregateInputType = {
    unit_id?: true
    role_id?: true
    nrp?: true
    name?: true
    rank?: true
    position?: true
    phone?: true
    email?: true
    avatar?: true
    valid_until?: true
    qr_code?: true
    created_at?: true
    updated_at?: true
    patrol_unit_id?: true
    id?: true
    banned_reason?: true
    banned_until?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
    place_of_birth?: true
    date_of_birth?: true
  }

  export type OfficersCountAggregateInputType = {
    unit_id?: true
    role_id?: true
    nrp?: true
    name?: true
    rank?: true
    position?: true
    phone?: true
    email?: true
    avatar?: true
    valid_until?: true
    qr_code?: true
    created_at?: true
    updated_at?: true
    patrol_unit_id?: true
    id?: true
    banned_reason?: true
    banned_until?: true
    is_banned?: true
    panic_strike?: true
    spoofing_attempts?: true
    place_of_birth?: true
    date_of_birth?: true
    _all?: true
  }

  export type OfficersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which officers to aggregate.
     */
    where?: officersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of officers to fetch.
     */
    orderBy?: officersOrderByWithRelationInput | officersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: officersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` officers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` officers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned officers
    **/
    _count?: true | OfficersCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: OfficersAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: OfficersSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OfficersMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OfficersMaxAggregateInputType
  }

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




  export type officersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: officersWhereInput
    orderBy?: officersOrderByWithAggregationInput | officersOrderByWithAggregationInput[]
    by: OfficersScalarFieldEnum[] | OfficersScalarFieldEnum
    having?: officersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OfficersCountAggregateInputType | true
    _avg?: OfficersAvgAggregateInputType
    _sum?: OfficersSumAggregateInputType
    _min?: OfficersMinAggregateInputType
    _max?: OfficersMaxAggregateInputType
  }

  export type OfficersGroupByOutputType = {
    unit_id: string | null
    role_id: string
    nrp: string | null
    name: string
    rank: string | null
    position: string | null
    phone: string | null
    email: string | null
    avatar: string | null
    valid_until: Date | null
    qr_code: string | null
    created_at: Date | null
    updated_at: Date | null
    patrol_unit_id: string | null
    id: string
    banned_reason: string | null
    banned_until: Date | null
    is_banned: boolean
    panic_strike: number
    spoofing_attempts: number
    place_of_birth: string | null
    date_of_birth: Date | null
    _count: OfficersCountAggregateOutputType | null
    _avg: OfficersAvgAggregateOutputType | null
    _sum: OfficersSumAggregateOutputType | null
    _min: OfficersMinAggregateOutputType | null
    _max: OfficersMaxAggregateOutputType | null
  }

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


  export type officersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    role_id?: boolean
    nrp?: boolean
    name?: boolean
    rank?: boolean
    position?: boolean
    phone?: boolean
    email?: boolean
    avatar?: boolean
    valid_until?: boolean
    qr_code?: boolean
    created_at?: boolean
    updated_at?: boolean
    patrol_unit_id?: boolean
    id?: boolean
    banned_reason?: boolean
    banned_until?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    place_of_birth?: boolean
    date_of_birth?: boolean
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
    panic_button_logs?: boolean | officers$panic_button_logsArgs<ExtArgs>
    sentMessages?: boolean | officers$sentMessagesArgs<ExtArgs>
    receivedMessages?: boolean | officers$receivedMessagesArgs<ExtArgs>
    inbox?: boolean | officers$inboxArgs<ExtArgs>
    _count?: boolean | OfficersCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["officers"]>

  export type officersSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    role_id?: boolean
    nrp?: boolean
    name?: boolean
    rank?: boolean
    position?: boolean
    phone?: boolean
    email?: boolean
    avatar?: boolean
    valid_until?: boolean
    qr_code?: boolean
    created_at?: boolean
    updated_at?: boolean
    patrol_unit_id?: boolean
    id?: boolean
    banned_reason?: boolean
    banned_until?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    place_of_birth?: boolean
    date_of_birth?: boolean
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
  }, ExtArgs["result"]["officers"]>

  export type officersSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    unit_id?: boolean
    role_id?: boolean
    nrp?: boolean
    name?: boolean
    rank?: boolean
    position?: boolean
    phone?: boolean
    email?: boolean
    avatar?: boolean
    valid_until?: boolean
    qr_code?: boolean
    created_at?: boolean
    updated_at?: boolean
    patrol_unit_id?: boolean
    id?: boolean
    banned_reason?: boolean
    banned_until?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    place_of_birth?: boolean
    date_of_birth?: boolean
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
  }, ExtArgs["result"]["officers"]>

  export type officersSelectScalar = {
    unit_id?: boolean
    role_id?: boolean
    nrp?: boolean
    name?: boolean
    rank?: boolean
    position?: boolean
    phone?: boolean
    email?: boolean
    avatar?: boolean
    valid_until?: boolean
    qr_code?: boolean
    created_at?: boolean
    updated_at?: boolean
    patrol_unit_id?: boolean
    id?: boolean
    banned_reason?: boolean
    banned_until?: boolean
    is_banned?: boolean
    panic_strike?: boolean
    spoofing_attempts?: boolean
    place_of_birth?: boolean
    date_of_birth?: boolean
  }

  export type officersOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"unit_id" | "role_id" | "nrp" | "name" | "rank" | "position" | "phone" | "email" | "avatar" | "valid_until" | "qr_code" | "created_at" | "updated_at" | "patrol_unit_id" | "id" | "banned_reason" | "banned_until" | "is_banned" | "panic_strike" | "spoofing_attempts" | "place_of_birth" | "date_of_birth", ExtArgs["result"]["officers"]>
  export type officersInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
    panic_button_logs?: boolean | officers$panic_button_logsArgs<ExtArgs>
    sentMessages?: boolean | officers$sentMessagesArgs<ExtArgs>
    receivedMessages?: boolean | officers$receivedMessagesArgs<ExtArgs>
    inbox?: boolean | officers$inboxArgs<ExtArgs>
    _count?: boolean | OfficersCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type officersIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
  }
  export type officersIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    patrol_units?: boolean | officers$patrol_unitsArgs<ExtArgs>
    roles?: boolean | rolesDefaultArgs<ExtArgs>
    units?: boolean | officers$unitsArgs<ExtArgs>
  }

  export type $officersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "officers"
    objects: {
      patrol_units: Prisma.$patrol_unitsPayload<ExtArgs> | null
      roles: Prisma.$rolesPayload<ExtArgs>
      units: Prisma.$unitsPayload<ExtArgs> | null
      panic_button_logs: Prisma.$panic_button_logsPayload<ExtArgs>[]
      sentMessages: Prisma.$messagesPayload<ExtArgs>[]
      receivedMessages: Prisma.$messagesPayload<ExtArgs>[]
      inbox: Prisma.$inboxPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      unit_id: string | null
      role_id: string
      nrp: string | null
      name: string
      rank: string | null
      position: string | null
      phone: string | null
      email: string | null
      avatar: string | null
      valid_until: Date | null
      qr_code: string | null
      created_at: Date | null
      updated_at: Date | null
      patrol_unit_id: string | null
      id: string
      banned_reason: string | null
      banned_until: Date | null
      is_banned: boolean
      panic_strike: number
      spoofing_attempts: number
      place_of_birth: string | null
      date_of_birth: Date | null
    }, ExtArgs["result"]["officers"]>
    composites: {}
  }

  type officersGetPayload<S extends boolean | null | undefined | officersDefaultArgs> = $Result.GetResult<Prisma.$officersPayload, S>

  type officersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<officersFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: OfficersCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Officers.
     * @param {officersCreateArgs} args - Arguments to create a Officers.
     * @example
     * // Create one Officers
     * const Officers = await prisma.officers.create({
     *   data: {
     *     // ... data to create a Officers
     *   }
     * })
     * 
     */
    create<T extends officersCreateArgs>(args: SelectSubset<T, officersCreateArgs<ExtArgs>>): Prisma__officersClient<$Result.GetResult<Prisma.$officersPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Officers.
     * @param {officersDeleteArgs} args - Arguments to delete one Officers.
     * @example
     * // Delete one Officers
     * const Officers = await prisma.officers.delete({
     *   where: {
     *     // ... filter to delete one Officers
     *   }
     * })
     * 
     */
    delete<T extends officersDeleteArgs>(args: SelectSubset<T, officersDeleteArgs<ExtArgs>>): Prisma__officersClient<$Result.GetResult<Prisma.$officersPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for officers.
   * 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__officersClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    patrol_units<T extends officers$patrol_unitsArgs<ExtArgs> = {}>(args?: Subset<T, officers$patrol_unitsArgs<ExtArgs>>): Prisma__patrol_unitsClient<$Result.GetResult<Prisma.$patrol_unitsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    roles<T extends rolesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, rolesDefaultArgs<ExtArgs>>): Prisma__rolesClient<$Result.GetResult<Prisma.$rolesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    units<T extends officers$unitsArgs<ExtArgs> = {}>(args?: Subset<T, officers$unitsArgs<ExtArgs>>): Prisma__unitsClient<$Result.GetResult<Prisma.$unitsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    panic_button_logs<T extends officers$panic_button_logsArgs<ExtArgs> = {}>(args?: Subset<T, officers$panic_button_logsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$panic_button_logsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    sentMessages<T extends officers$sentMessagesArgs<ExtArgs> = {}>(args?: Subset<T, officers$sentMessagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    receivedMessages<T extends officers$receivedMessagesArgs<ExtArgs> = {}>(args?: Subset<T, officers$receivedMessagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    inbox<T extends officers$inboxArgs<ExtArgs> = {}>(args?: Subset<T, officers$inboxArgs<ExtArgs>>): Prisma__inboxClient<$Result.GetResult<Prisma.$inboxPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the officers model
   */
  interface officersFieldRefs {
    readonly unit_id: FieldRef<"officers", 'String'>
    readonly role_id: FieldRef<"officers", 'String'>
    readonly nrp: FieldRef<"officers", 'String'>
    readonly name: FieldRef<"officers", 'String'>
    readonly rank: FieldRef<"officers", 'String'>
    readonly position: FieldRef<"officers", 'String'>
    readonly phone: FieldRef<"officers", 'String'>
    readonly email: FieldRef<"officers", 'String'>
    readonly avatar: FieldRef<"officers", 'String'>
    readonly valid_until: FieldRef<"officers", 'DateTime'>
    readonly qr_code: FieldRef<"officers", 'String'>
    readonly created_at: FieldRef<"officers", 'DateTime'>
    readonly updated_at: FieldRef<"officers", 'DateTime'>
    readonly patrol_unit_id: FieldRef<"officers", 'String'>
    readonly id: FieldRef<"officers", 'String'>
    readonly banned_reason: FieldRef<"officers", 'String'>
    readonly banned_until: FieldRef<"officers", 'DateTime'>
    readonly is_banned: FieldRef<"officers", 'Boolean'>
    readonly panic_strike: FieldRef<"officers", 'Int'>
    readonly spoofing_attempts: FieldRef<"officers", 'Int'>
    readonly place_of_birth: FieldRef<"officers", 'String'>
    readonly date_of_birth: FieldRef<"officers", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * officers findUnique
   */
  export type officersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * Filter, which officers to fetch.
     */
    where: officersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * officers findUniqueOrThrow
   */
  export type officersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * Filter, which officers to fetch.
     */
    where: officersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * officers findMany
   */
  export type officersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * Filter, which officers to fetch.
     */
    where?: officersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of officers to fetch.
     */
    orderBy?: officersOrderByWithRelationInput | officersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing officers.
     */
    cursor?: officersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` officers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` officers.
     */
    skip?: number
    distinct?: OfficersScalarFieldEnum | OfficersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * officers create
   */
  export type officersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * The data needed to create a officers.
     */
    data: XOR<officersCreateInput, officersUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * officers update
   */
  export type officersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * The data needed to update a officers.
     */
    data: XOR<officersUpdateInput, officersUncheckedUpdateInput>
    /**
     * Choose, which officers to update.
     */
    where: officersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * officers updateMany
   */
  export type officersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update officers.
     */
    data: XOR<officersUpdateManyMutationInput, officersUncheckedUpdateManyInput>
    /**
     * Filter which officers to update
     */
    where?: officersWhereInput
    /**
     * Limit how many officers to update.
     */
    limit?: number
  }

  /**
   * officers updateManyAndReturn
   */
  export type officersUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * The data used to update officers.
     */
    data: XOR<officersUpdateManyMutationInput, officersUncheckedUpdateManyInput>
    /**
     * Filter which officers to update
     */
    where?: officersWhereInput
    /**
     * Limit how many officers to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * officers upsert
   */
  export type officersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * The filter to search for the officers to update in case it exists.
     */
    where: officersWhereUniqueInput
    /**
     * In case the officers found by the `where` argument doesn't exist, create a new officers with this data.
     */
    create: XOR<officersCreateInput, officersUncheckedCreateInput>
    /**
     * In case the officers was found with the provided `where` argument, update it with this data.
     */
    update: XOR<officersUpdateInput, officersUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * officers delete
   */
  export type officersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    /**
     * Filter which officers to delete.
     */
    where: officersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * officers.patrol_units
   */
  export type officers$patrol_unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the patrol_units
     */
    select?: patrol_unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the patrol_units
     */
    omit?: patrol_unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: patrol_unitsInclude<ExtArgs> | null
    where?: patrol_unitsWhereInput
  }

  /**
   * officers.units
   */
  export type officers$unitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the units
     */
    select?: unitsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the units
     */
    omit?: unitsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unitsInclude<ExtArgs> | null
    where?: unitsWhereInput
  }

  /**
   * officers.panic_button_logs
   */
  export type officers$panic_button_logsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    where?: panic_button_logsWhereInput
    orderBy?: panic_button_logsOrderByWithRelationInput | panic_button_logsOrderByWithRelationInput[]
    cursor?: panic_button_logsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: Panic_button_logsScalarFieldEnum | Panic_button_logsScalarFieldEnum[]
  }

  /**
   * officers.sentMessages
   */
  export type officers$sentMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    cursor?: messagesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }

  /**
   * officers.receivedMessages
   */
  export type officers$receivedMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    cursor?: messagesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }

  /**
   * officers.inbox
   */
  export type officers$inboxArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    where?: inboxWhereInput
  }

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


  /**
   * Model unit_statistics
   */

  export type AggregateUnit_statistics = {
    _count: Unit_statisticsCountAggregateOutputType | null
    _avg: Unit_statisticsAvgAggregateOutputType | null
    _sum: Unit_statisticsSumAggregateOutputType | null
    _min: Unit_statisticsMinAggregateOutputType | null
    _max: Unit_statisticsMaxAggregateOutputType | null
  }

  export type Unit_statisticsAvgAggregateOutputType = {
    crime_total: number | null
    crime_cleared: number | null
    percentage: number | null
    pending: number | null
    month: number | null
    year: number | null
  }

  export type Unit_statisticsSumAggregateOutputType = {
    crime_total: number | null
    crime_cleared: number | null
    percentage: number | null
    pending: number | null
    month: number | null
    year: number | null
  }

  export type Unit_statisticsMinAggregateOutputType = {
    id: string | null
    crime_total: number | null
    crime_cleared: number | null
    percentage: number | null
    pending: number | null
    month: number | null
    year: number | null
    created_at: Date | null
    updated_at: Date | null
    code_unit: string | null
  }

  export type Unit_statisticsMaxAggregateOutputType = {
    id: string | null
    crime_total: number | null
    crime_cleared: number | null
    percentage: number | null
    pending: number | null
    month: number | null
    year: number | null
    created_at: Date | null
    updated_at: Date | null
    code_unit: string | null
  }

  export type Unit_statisticsCountAggregateOutputType = {
    id: number
    crime_total: number
    crime_cleared: number
    percentage: number
    pending: number
    month: number
    year: number
    created_at: number
    updated_at: number
    code_unit: number
    _all: number
  }


  export type Unit_statisticsAvgAggregateInputType = {
    crime_total?: true
    crime_cleared?: true
    percentage?: true
    pending?: true
    month?: true
    year?: true
  }

  export type Unit_statisticsSumAggregateInputType = {
    crime_total?: true
    crime_cleared?: true
    percentage?: true
    pending?: true
    month?: true
    year?: true
  }

  export type Unit_statisticsMinAggregateInputType = {
    id?: true
    crime_total?: true
    crime_cleared?: true
    percentage?: true
    pending?: true
    month?: true
    year?: true
    created_at?: true
    updated_at?: true
    code_unit?: true
  }

  export type Unit_statisticsMaxAggregateInputType = {
    id?: true
    crime_total?: true
    crime_cleared?: true
    percentage?: true
    pending?: true
    month?: true
    year?: true
    created_at?: true
    updated_at?: true
    code_unit?: true
  }

  export type Unit_statisticsCountAggregateInputType = {
    id?: true
    crime_total?: true
    crime_cleared?: true
    percentage?: true
    pending?: true
    month?: true
    year?: true
    created_at?: true
    updated_at?: true
    code_unit?: true
    _all?: true
  }

  export type Unit_statisticsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which unit_statistics to aggregate.
     */
    where?: unit_statisticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of unit_statistics to fetch.
     */
    orderBy?: unit_statisticsOrderByWithRelationInput | unit_statisticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: unit_statisticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` unit_statistics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` unit_statistics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned unit_statistics
    **/
    _count?: true | Unit_statisticsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Unit_statisticsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Unit_statisticsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Unit_statisticsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Unit_statisticsMaxAggregateInputType
  }

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




  export type unit_statisticsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: unit_statisticsWhereInput
    orderBy?: unit_statisticsOrderByWithAggregationInput | unit_statisticsOrderByWithAggregationInput[]
    by: Unit_statisticsScalarFieldEnum[] | Unit_statisticsScalarFieldEnum
    having?: unit_statisticsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Unit_statisticsCountAggregateInputType | true
    _avg?: Unit_statisticsAvgAggregateInputType
    _sum?: Unit_statisticsSumAggregateInputType
    _min?: Unit_statisticsMinAggregateInputType
    _max?: Unit_statisticsMaxAggregateInputType
  }

  export type Unit_statisticsGroupByOutputType = {
    id: string
    crime_total: number
    crime_cleared: number
    percentage: number | null
    pending: number | null
    month: number
    year: number
    created_at: Date | null
    updated_at: Date | null
    code_unit: string
    _count: Unit_statisticsCountAggregateOutputType | null
    _avg: Unit_statisticsAvgAggregateOutputType | null
    _sum: Unit_statisticsSumAggregateOutputType | null
    _min: Unit_statisticsMinAggregateOutputType | null
    _max: Unit_statisticsMaxAggregateOutputType | null
  }

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


  export type unit_statisticsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_total?: boolean
    crime_cleared?: boolean
    percentage?: boolean
    pending?: boolean
    month?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    code_unit?: boolean
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["unit_statistics"]>

  export type unit_statisticsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_total?: boolean
    crime_cleared?: boolean
    percentage?: boolean
    pending?: boolean
    month?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    code_unit?: boolean
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["unit_statistics"]>

  export type unit_statisticsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    crime_total?: boolean
    crime_cleared?: boolean
    percentage?: boolean
    pending?: boolean
    month?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    code_unit?: boolean
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["unit_statistics"]>

  export type unit_statisticsSelectScalar = {
    id?: boolean
    crime_total?: boolean
    crime_cleared?: boolean
    percentage?: boolean
    pending?: boolean
    month?: boolean
    year?: boolean
    created_at?: boolean
    updated_at?: boolean
    code_unit?: boolean
  }

  export type unit_statisticsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "crime_total" | "crime_cleared" | "percentage" | "pending" | "month" | "year" | "created_at" | "updated_at" | "code_unit", ExtArgs["result"]["unit_statistics"]>
  export type unit_statisticsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }
  export type unit_statisticsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }
  export type unit_statisticsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    units?: boolean | unitsDefaultArgs<ExtArgs>
  }

  export type $unit_statisticsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "unit_statistics"
    objects: {
      units: Prisma.$unitsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      crime_total: number
      crime_cleared: number
      percentage: number | null
      pending: number | null
      month: number
      year: number
      created_at: Date | null
      updated_at: Date | null
      code_unit: string
    }, ExtArgs["result"]["unit_statistics"]>
    composites: {}
  }

  type unit_statisticsGetPayload<S extends boolean | null | undefined | unit_statisticsDefaultArgs> = $Result.GetResult<Prisma.$unit_statisticsPayload, S>

  type unit_statisticsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<unit_statisticsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Unit_statisticsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Unit_statistics.
     * @param {unit_statisticsCreateArgs} args - Arguments to create a Unit_statistics.
     * @example
     * // Create one Unit_statistics
     * const Unit_statistics = await prisma.unit_statistics.create({
     *   data: {
     *     // ... data to create a Unit_statistics
     *   }
     * })
     * 
     */
    create<T extends unit_statisticsCreateArgs>(args: SelectSubset<T, unit_statisticsCreateArgs<ExtArgs>>): Prisma__unit_statisticsClient<$Result.GetResult<Prisma.$unit_statisticsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Unit_statistics.
     * @param {unit_statisticsDeleteArgs} args - Arguments to delete one Unit_statistics.
     * @example
     * // Delete one Unit_statistics
     * const Unit_statistics = await prisma.unit_statistics.delete({
     *   where: {
     *     // ... filter to delete one Unit_statistics
     *   }
     * })
     * 
     */
    delete<T extends unit_statisticsDeleteArgs>(args: SelectSubset<T, unit_statisticsDeleteArgs<ExtArgs>>): Prisma__unit_statisticsClient<$Result.GetResult<Prisma.$unit_statisticsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the unit_statistics model
   */
  interface unit_statisticsFieldRefs {
    readonly id: FieldRef<"unit_statistics", 'String'>
    readonly crime_total: FieldRef<"unit_statistics", 'Int'>
    readonly crime_cleared: FieldRef<"unit_statistics", 'Int'>
    readonly percentage: FieldRef<"unit_statistics", 'Float'>
    readonly pending: FieldRef<"unit_statistics", 'Int'>
    readonly month: FieldRef<"unit_statistics", 'Int'>
    readonly year: FieldRef<"unit_statistics", 'Int'>
    readonly created_at: FieldRef<"unit_statistics", 'DateTime'>
    readonly updated_at: FieldRef<"unit_statistics", 'DateTime'>
    readonly code_unit: FieldRef<"unit_statistics", 'String'>
  }
    

  // Custom InputTypes
  /**
   * unit_statistics findUnique
   */
  export type unit_statisticsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * Filter, which unit_statistics to fetch.
     */
    where: unit_statisticsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * unit_statistics findUniqueOrThrow
   */
  export type unit_statisticsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * Filter, which unit_statistics to fetch.
     */
    where: unit_statisticsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * unit_statistics findMany
   */
  export type unit_statisticsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * Filter, which unit_statistics to fetch.
     */
    where?: unit_statisticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of unit_statistics to fetch.
     */
    orderBy?: unit_statisticsOrderByWithRelationInput | unit_statisticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing unit_statistics.
     */
    cursor?: unit_statisticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` unit_statistics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` unit_statistics.
     */
    skip?: number
    distinct?: Unit_statisticsScalarFieldEnum | Unit_statisticsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * unit_statistics create
   */
  export type unit_statisticsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * The data needed to create a unit_statistics.
     */
    data: XOR<unit_statisticsCreateInput, unit_statisticsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * unit_statistics update
   */
  export type unit_statisticsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * The data needed to update a unit_statistics.
     */
    data: XOR<unit_statisticsUpdateInput, unit_statisticsUncheckedUpdateInput>
    /**
     * Choose, which unit_statistics to update.
     */
    where: unit_statisticsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * unit_statistics updateMany
   */
  export type unit_statisticsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update unit_statistics.
     */
    data: XOR<unit_statisticsUpdateManyMutationInput, unit_statisticsUncheckedUpdateManyInput>
    /**
     * Filter which unit_statistics to update
     */
    where?: unit_statisticsWhereInput
    /**
     * Limit how many unit_statistics to update.
     */
    limit?: number
  }

  /**
   * unit_statistics updateManyAndReturn
   */
  export type unit_statisticsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * The data used to update unit_statistics.
     */
    data: XOR<unit_statisticsUpdateManyMutationInput, unit_statisticsUncheckedUpdateManyInput>
    /**
     * Filter which unit_statistics to update
     */
    where?: unit_statisticsWhereInput
    /**
     * Limit how many unit_statistics to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * unit_statistics upsert
   */
  export type unit_statisticsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * The filter to search for the unit_statistics to update in case it exists.
     */
    where: unit_statisticsWhereUniqueInput
    /**
     * In case the unit_statistics found by the `where` argument doesn't exist, create a new unit_statistics with this data.
     */
    create: XOR<unit_statisticsCreateInput, unit_statisticsUncheckedCreateInput>
    /**
     * In case the unit_statistics was found with the provided `where` argument, update it with this data.
     */
    update: XOR<unit_statisticsUpdateInput, unit_statisticsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * unit_statistics delete
   */
  export type unit_statisticsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the unit_statistics
     */
    select?: unit_statisticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the unit_statistics
     */
    omit?: unit_statisticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: unit_statisticsInclude<ExtArgs> | null
    /**
     * Filter which unit_statistics to delete.
     */
    where: unit_statisticsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model geographics
   */

  export type AggregateGeographics = {
    _count: GeographicsCountAggregateOutputType | null
    _avg: GeographicsAvgAggregateOutputType | null
    _sum: GeographicsSumAggregateOutputType | null
    _min: GeographicsMinAggregateOutputType | null
    _max: GeographicsMaxAggregateOutputType | null
  }

  export type GeographicsAvgAggregateOutputType = {
    longitude: number | null
    latitude: number | null
    land_area: number | null
    year: number | null
  }

  export type GeographicsSumAggregateOutputType = {
    longitude: number | null
    latitude: number | null
    land_area: number | null
    year: number | null
  }

  export type GeographicsMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    address: string | null
    longitude: number | null
    latitude: number | null
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    description: string | null
    type: string | null
    year: number | null
  }

  export type GeographicsMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    address: string | null
    longitude: number | null
    latitude: number | null
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    description: string | null
    type: string | null
    year: number | null
  }

  export type GeographicsCountAggregateOutputType = {
    id: number
    district_id: number
    address: number
    longitude: number
    latitude: number
    land_area: number
    created_at: number
    updated_at: number
    description: number
    type: number
    year: number
    _all: number
  }


  export type GeographicsAvgAggregateInputType = {
    longitude?: true
    latitude?: true
    land_area?: true
    year?: true
  }

  export type GeographicsSumAggregateInputType = {
    longitude?: true
    latitude?: true
    land_area?: true
    year?: true
  }

  export type GeographicsMinAggregateInputType = {
    id?: true
    district_id?: true
    address?: true
    longitude?: true
    latitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    description?: true
    type?: true
    year?: true
  }

  export type GeographicsMaxAggregateInputType = {
    id?: true
    district_id?: true
    address?: true
    longitude?: true
    latitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    description?: true
    type?: true
    year?: true
  }

  export type GeographicsCountAggregateInputType = {
    id?: true
    district_id?: true
    address?: true
    longitude?: true
    latitude?: true
    land_area?: true
    created_at?: true
    updated_at?: true
    description?: true
    type?: true
    year?: true
    _all?: true
  }

  export type GeographicsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which geographics to aggregate.
     */
    where?: geographicsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of geographics to fetch.
     */
    orderBy?: geographicsOrderByWithRelationInput | geographicsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: geographicsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` geographics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` geographics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned geographics
    **/
    _count?: true | GeographicsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: GeographicsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: GeographicsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GeographicsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GeographicsMaxAggregateInputType
  }

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




  export type geographicsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: geographicsWhereInput
    orderBy?: geographicsOrderByWithAggregationInput | geographicsOrderByWithAggregationInput[]
    by: GeographicsScalarFieldEnum[] | GeographicsScalarFieldEnum
    having?: geographicsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GeographicsCountAggregateInputType | true
    _avg?: GeographicsAvgAggregateInputType
    _sum?: GeographicsSumAggregateInputType
    _min?: GeographicsMinAggregateInputType
    _max?: GeographicsMaxAggregateInputType
  }

  export type GeographicsGroupByOutputType = {
    id: string
    district_id: string
    address: string | null
    longitude: number
    latitude: number
    land_area: number | null
    created_at: Date | null
    updated_at: Date | null
    description: string | null
    type: string | null
    year: number | null
    _count: GeographicsCountAggregateOutputType | null
    _avg: GeographicsAvgAggregateOutputType | null
    _sum: GeographicsSumAggregateOutputType | null
    _min: GeographicsMinAggregateOutputType | null
    _max: GeographicsMaxAggregateOutputType | null
  }

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


  export type geographicsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    address?: boolean
    longitude?: boolean
    latitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    description?: boolean
    type?: boolean
    year?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["geographics"]>


  export type geographicsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    address?: boolean
    longitude?: boolean
    latitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    description?: boolean
    type?: boolean
    year?: boolean
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["geographics"]>

  export type geographicsSelectScalar = {
    id?: boolean
    district_id?: boolean
    address?: boolean
    longitude?: boolean
    latitude?: boolean
    land_area?: boolean
    created_at?: boolean
    updated_at?: boolean
    description?: boolean
    type?: boolean
    year?: boolean
  }

  export type geographicsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "address" | "longitude" | "latitude" | "land_area" | "created_at" | "updated_at" | "description" | "type" | "year", ExtArgs["result"]["geographics"]>
  export type geographicsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type geographicsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    districts?: boolean | districtsDefaultArgs<ExtArgs>
  }

  export type $geographicsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "geographics"
    objects: {
      districts: Prisma.$districtsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      address: string | null
      longitude: number
      latitude: number
      land_area: number | null
      created_at: Date | null
      updated_at: Date | null
      description: string | null
      type: string | null
      year: number | null
    }, ExtArgs["result"]["geographics"]>
    composites: {}
  }

  type geographicsGetPayload<S extends boolean | null | undefined | geographicsDefaultArgs> = $Result.GetResult<Prisma.$geographicsPayload, S>

  type geographicsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<geographicsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: GeographicsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Delete a Geographics.
     * @param {geographicsDeleteArgs} args - Arguments to delete one Geographics.
     * @example
     * // Delete one Geographics
     * const Geographics = await prisma.geographics.delete({
     *   where: {
     *     // ... filter to delete one Geographics
     *   }
     * })
     * 
     */
    delete<T extends geographicsDeleteArgs>(args: SelectSubset<T, geographicsDeleteArgs<ExtArgs>>): Prisma__geographicsClient<$Result.GetResult<Prisma.$geographicsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

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




  /**
   * Fields of the geographics model
   */
  interface geographicsFieldRefs {
    readonly id: FieldRef<"geographics", 'String'>
    readonly district_id: FieldRef<"geographics", 'String'>
    readonly address: FieldRef<"geographics", 'String'>
    readonly longitude: FieldRef<"geographics", 'Float'>
    readonly latitude: FieldRef<"geographics", 'Float'>
    readonly land_area: FieldRef<"geographics", 'Float'>
    readonly created_at: FieldRef<"geographics", 'DateTime'>
    readonly updated_at: FieldRef<"geographics", 'DateTime'>
    readonly description: FieldRef<"geographics", 'String'>
    readonly type: FieldRef<"geographics", 'String'>
    readonly year: FieldRef<"geographics", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * geographics findUnique
   */
  export type geographicsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    /**
     * Filter, which geographics to fetch.
     */
    where: geographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * geographics findUniqueOrThrow
   */
  export type geographicsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    /**
     * Filter, which geographics to fetch.
     */
    where: geographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * geographics findMany
   */
  export type geographicsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    /**
     * Filter, which geographics to fetch.
     */
    where?: geographicsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of geographics to fetch.
     */
    orderBy?: geographicsOrderByWithRelationInput | geographicsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing geographics.
     */
    cursor?: geographicsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` geographics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` geographics.
     */
    skip?: number
    distinct?: GeographicsScalarFieldEnum | GeographicsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * geographics update
   */
  export type geographicsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    /**
     * The data needed to update a geographics.
     */
    data: XOR<geographicsUpdateInput, geographicsUncheckedUpdateInput>
    /**
     * Choose, which geographics to update.
     */
    where: geographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * geographics updateMany
   */
  export type geographicsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update geographics.
     */
    data: XOR<geographicsUpdateManyMutationInput, geographicsUncheckedUpdateManyInput>
    /**
     * Filter which geographics to update
     */
    where?: geographicsWhereInput
    /**
     * Limit how many geographics to update.
     */
    limit?: number
  }

  /**
   * geographics updateManyAndReturn
   */
  export type geographicsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * The data used to update geographics.
     */
    data: XOR<geographicsUpdateManyMutationInput, geographicsUncheckedUpdateManyInput>
    /**
     * Filter which geographics to update
     */
    where?: geographicsWhereInput
    /**
     * Limit how many geographics to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * geographics delete
   */
  export type geographicsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the geographics
     */
    select?: geographicsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the geographics
     */
    omit?: geographicsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: geographicsInclude<ExtArgs> | null
    /**
     * Filter which geographics to delete.
     */
    where: geographicsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model contact_messages
   */

  export type AggregateContact_messages = {
    _count: Contact_messagesCountAggregateOutputType | null
    _min: Contact_messagesMinAggregateOutputType | null
    _max: Contact_messagesMaxAggregateOutputType | null
  }

  export type Contact_messagesMinAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    phone: string | null
    message_type: string | null
    message_type_label: string | null
    message: string | null
    status: $Enums.status_messages | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Contact_messagesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    phone: string | null
    message_type: string | null
    message_type_label: string | null
    message: string | null
    status: $Enums.status_messages | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Contact_messagesCountAggregateOutputType = {
    id: number
    name: number
    email: number
    phone: number
    message_type: number
    message_type_label: number
    message: number
    status: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type Contact_messagesMinAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    message_type?: true
    message_type_label?: true
    message?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type Contact_messagesMaxAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    message_type?: true
    message_type_label?: true
    message?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type Contact_messagesCountAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    message_type?: true
    message_type_label?: true
    message?: true
    status?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type contact_messagesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: contact_messagesWhereInput
    orderBy?: contact_messagesOrderByWithAggregationInput | contact_messagesOrderByWithAggregationInput[]
    by: Contact_messagesScalarFieldEnum[] | Contact_messagesScalarFieldEnum
    having?: contact_messagesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Contact_messagesCountAggregateInputType | true
    _min?: Contact_messagesMinAggregateInputType
    _max?: Contact_messagesMaxAggregateInputType
  }

  export type Contact_messagesGroupByOutputType = {
    id: string
    name: string | null
    email: string | null
    phone: string | null
    message_type: string | null
    message_type_label: string | null
    message: string | null
    status: $Enums.status_messages
    created_at: Date
    updated_at: Date
    _count: Contact_messagesCountAggregateOutputType | null
    _min: Contact_messagesMinAggregateOutputType | null
    _max: Contact_messagesMaxAggregateOutputType | null
  }

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


  export type contact_messagesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    message_type?: boolean
    message_type_label?: boolean
    message?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["contact_messages"]>

  export type contact_messagesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    message_type?: boolean
    message_type_label?: boolean
    message?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["contact_messages"]>

  export type contact_messagesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    message_type?: boolean
    message_type_label?: boolean
    message?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["contact_messages"]>

  export type contact_messagesSelectScalar = {
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    message_type?: boolean
    message_type_label?: boolean
    message?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type contact_messagesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "email" | "phone" | "message_type" | "message_type_label" | "message" | "status" | "created_at" | "updated_at", ExtArgs["result"]["contact_messages"]>

  export type $contact_messagesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "contact_messages"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      email: string | null
      phone: string | null
      message_type: string | null
      message_type_label: string | null
      message: string | null
      status: $Enums.status_messages
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["contact_messages"]>
    composites: {}
  }

  type contact_messagesGetPayload<S extends boolean | null | undefined | contact_messagesDefaultArgs> = $Result.GetResult<Prisma.$contact_messagesPayload, S>

  type contact_messagesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<contact_messagesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Contact_messagesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Contact_messages.
     * @param {contact_messagesCreateArgs} args - Arguments to create a Contact_messages.
     * @example
     * // Create one Contact_messages
     * const Contact_messages = await prisma.contact_messages.create({
     *   data: {
     *     // ... data to create a Contact_messages
     *   }
     * })
     * 
     */
    create<T extends contact_messagesCreateArgs>(args: SelectSubset<T, contact_messagesCreateArgs<ExtArgs>>): Prisma__contact_messagesClient<$Result.GetResult<Prisma.$contact_messagesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Contact_messages.
     * @param {contact_messagesDeleteArgs} args - Arguments to delete one Contact_messages.
     * @example
     * // Delete one Contact_messages
     * const Contact_messages = await prisma.contact_messages.delete({
     *   where: {
     *     // ... filter to delete one Contact_messages
     *   }
     * })
     * 
     */
    delete<T extends contact_messagesDeleteArgs>(args: SelectSubset<T, contact_messagesDeleteArgs<ExtArgs>>): Prisma__contact_messagesClient<$Result.GetResult<Prisma.$contact_messagesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the contact_messages model
   */
  interface contact_messagesFieldRefs {
    readonly id: FieldRef<"contact_messages", 'String'>
    readonly name: FieldRef<"contact_messages", 'String'>
    readonly email: FieldRef<"contact_messages", 'String'>
    readonly phone: FieldRef<"contact_messages", 'String'>
    readonly message_type: FieldRef<"contact_messages", 'String'>
    readonly message_type_label: FieldRef<"contact_messages", 'String'>
    readonly message: FieldRef<"contact_messages", 'String'>
    readonly status: FieldRef<"contact_messages", 'status_messages'>
    readonly created_at: FieldRef<"contact_messages", 'DateTime'>
    readonly updated_at: FieldRef<"contact_messages", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * contact_messages findUnique
   */
  export type contact_messagesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter, which contact_messages to fetch.
     */
    where: contact_messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages findUniqueOrThrow
   */
  export type contact_messagesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter, which contact_messages to fetch.
     */
    where: contact_messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages findFirst
   */
  export type contact_messagesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter, which contact_messages to fetch.
     */
    where?: contact_messagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of contact_messages to fetch.
     */
    orderBy?: contact_messagesOrderByWithRelationInput | contact_messagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for contact_messages.
     */
    cursor?: contact_messagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` contact_messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` contact_messages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of contact_messages.
     */
    distinct?: Contact_messagesScalarFieldEnum | Contact_messagesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages findFirstOrThrow
   */
  export type contact_messagesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter, which contact_messages to fetch.
     */
    where?: contact_messagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of contact_messages to fetch.
     */
    orderBy?: contact_messagesOrderByWithRelationInput | contact_messagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for contact_messages.
     */
    cursor?: contact_messagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` contact_messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` contact_messages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of contact_messages.
     */
    distinct?: Contact_messagesScalarFieldEnum | Contact_messagesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages findMany
   */
  export type contact_messagesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter, which contact_messages to fetch.
     */
    where?: contact_messagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of contact_messages to fetch.
     */
    orderBy?: contact_messagesOrderByWithRelationInput | contact_messagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing contact_messages.
     */
    cursor?: contact_messagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` contact_messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` contact_messages.
     */
    skip?: number
    distinct?: Contact_messagesScalarFieldEnum | Contact_messagesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages create
   */
  export type contact_messagesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * The data needed to create a contact_messages.
     */
    data: XOR<contact_messagesCreateInput, contact_messagesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * contact_messages createManyAndReturn
   */
  export type contact_messagesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * The data used to create many contact_messages.
     */
    data: contact_messagesCreateManyInput | contact_messagesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * contact_messages update
   */
  export type contact_messagesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * The data needed to update a contact_messages.
     */
    data: XOR<contact_messagesUpdateInput, contact_messagesUncheckedUpdateInput>
    /**
     * Choose, which contact_messages to update.
     */
    where: contact_messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages updateMany
   */
  export type contact_messagesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update contact_messages.
     */
    data: XOR<contact_messagesUpdateManyMutationInput, contact_messagesUncheckedUpdateManyInput>
    /**
     * Filter which contact_messages to update
     */
    where?: contact_messagesWhereInput
    /**
     * Limit how many contact_messages to update.
     */
    limit?: number
  }

  /**
   * contact_messages updateManyAndReturn
   */
  export type contact_messagesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * The data used to update contact_messages.
     */
    data: XOR<contact_messagesUpdateManyMutationInput, contact_messagesUncheckedUpdateManyInput>
    /**
     * Filter which contact_messages to update
     */
    where?: contact_messagesWhereInput
    /**
     * Limit how many contact_messages to update.
     */
    limit?: number
  }

  /**
   * contact_messages upsert
   */
  export type contact_messagesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * The filter to search for the contact_messages to update in case it exists.
     */
    where: contact_messagesWhereUniqueInput
    /**
     * In case the contact_messages found by the `where` argument doesn't exist, create a new contact_messages with this data.
     */
    create: XOR<contact_messagesCreateInput, contact_messagesUncheckedCreateInput>
    /**
     * In case the contact_messages was found with the provided `where` argument, update it with this data.
     */
    update: XOR<contact_messagesUpdateInput, contact_messagesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * contact_messages delete
   */
  export type contact_messagesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
    /**
     * Filter which contact_messages to delete.
     */
    where: contact_messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * contact_messages without action
   */
  export type contact_messagesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the contact_messages
     */
    select?: contact_messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the contact_messages
     */
    omit?: contact_messagesOmit<ExtArgs> | null
  }


  /**
   * Model messages
   */

  export type AggregateMessages = {
    _count: MessagesCountAggregateOutputType | null
    _min: MessagesMinAggregateOutputType | null
    _max: MessagesMaxAggregateOutputType | null
  }

  export type MessagesMinAggregateOutputType = {
    id: string | null
    subject: string | null
    content: string | null
    message_type: string | null
    message_type_label: string | null
    sender_user_id: string | null
    sender_officer_id: string | null
    recipient_user_id: string | null
    recipient_officer_id: string | null
    inbox_id: string | null
    status: $Enums.status_messages | null
    created_at: Date | null
    updated_at: Date | null
    file_url: string | null
    file_type: string | null
    file_name: string | null
    is_starred: boolean | null
  }

  export type MessagesMaxAggregateOutputType = {
    id: string | null
    subject: string | null
    content: string | null
    message_type: string | null
    message_type_label: string | null
    sender_user_id: string | null
    sender_officer_id: string | null
    recipient_user_id: string | null
    recipient_officer_id: string | null
    inbox_id: string | null
    status: $Enums.status_messages | null
    created_at: Date | null
    updated_at: Date | null
    file_url: string | null
    file_type: string | null
    file_name: string | null
    is_starred: boolean | null
  }

  export type MessagesCountAggregateOutputType = {
    id: number
    subject: number
    content: number
    message_type: number
    message_type_label: number
    sender_user_id: number
    sender_officer_id: number
    recipient_user_id: number
    recipient_officer_id: number
    inbox_id: number
    status: number
    created_at: number
    updated_at: number
    file_url: number
    file_type: number
    file_name: number
    is_starred: number
    _all: number
  }


  export type MessagesMinAggregateInputType = {
    id?: true
    subject?: true
    content?: true
    message_type?: true
    message_type_label?: true
    sender_user_id?: true
    sender_officer_id?: true
    recipient_user_id?: true
    recipient_officer_id?: true
    inbox_id?: true
    status?: true
    created_at?: true
    updated_at?: true
    file_url?: true
    file_type?: true
    file_name?: true
    is_starred?: true
  }

  export type MessagesMaxAggregateInputType = {
    id?: true
    subject?: true
    content?: true
    message_type?: true
    message_type_label?: true
    sender_user_id?: true
    sender_officer_id?: true
    recipient_user_id?: true
    recipient_officer_id?: true
    inbox_id?: true
    status?: true
    created_at?: true
    updated_at?: true
    file_url?: true
    file_type?: true
    file_name?: true
    is_starred?: true
  }

  export type MessagesCountAggregateInputType = {
    id?: true
    subject?: true
    content?: true
    message_type?: true
    message_type_label?: true
    sender_user_id?: true
    sender_officer_id?: true
    recipient_user_id?: true
    recipient_officer_id?: true
    inbox_id?: true
    status?: true
    created_at?: true
    updated_at?: true
    file_url?: true
    file_type?: true
    file_name?: true
    is_starred?: true
    _all?: true
  }

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

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




  export type messagesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithAggregationInput | messagesOrderByWithAggregationInput[]
    by: MessagesScalarFieldEnum[] | MessagesScalarFieldEnum
    having?: messagesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MessagesCountAggregateInputType | true
    _min?: MessagesMinAggregateInputType
    _max?: MessagesMaxAggregateInputType
  }

  export type MessagesGroupByOutputType = {
    id: string
    subject: string
    content: string
    message_type: string | null
    message_type_label: string | null
    sender_user_id: string | null
    sender_officer_id: string | null
    recipient_user_id: string | null
    recipient_officer_id: string | null
    inbox_id: string | null
    status: $Enums.status_messages
    created_at: Date
    updated_at: Date
    file_url: string | null
    file_type: string | null
    file_name: string | null
    is_starred: boolean
    _count: MessagesCountAggregateOutputType | null
    _min: MessagesMinAggregateOutputType | null
    _max: MessagesMaxAggregateOutputType | null
  }

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


  export type messagesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subject?: boolean
    content?: boolean
    message_type?: boolean
    message_type_label?: boolean
    sender_user_id?: boolean
    sender_officer_id?: boolean
    recipient_user_id?: boolean
    recipient_officer_id?: boolean
    inbox_id?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    file_url?: boolean
    file_type?: boolean
    file_name?: boolean
    is_starred?: boolean
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }, ExtArgs["result"]["messages"]>

  export type messagesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subject?: boolean
    content?: boolean
    message_type?: boolean
    message_type_label?: boolean
    sender_user_id?: boolean
    sender_officer_id?: boolean
    recipient_user_id?: boolean
    recipient_officer_id?: boolean
    inbox_id?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    file_url?: boolean
    file_type?: boolean
    file_name?: boolean
    is_starred?: boolean
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }, ExtArgs["result"]["messages"]>

  export type messagesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subject?: boolean
    content?: boolean
    message_type?: boolean
    message_type_label?: boolean
    sender_user_id?: boolean
    sender_officer_id?: boolean
    recipient_user_id?: boolean
    recipient_officer_id?: boolean
    inbox_id?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    file_url?: boolean
    file_type?: boolean
    file_name?: boolean
    is_starred?: boolean
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }, ExtArgs["result"]["messages"]>

  export type messagesSelectScalar = {
    id?: boolean
    subject?: boolean
    content?: boolean
    message_type?: boolean
    message_type_label?: boolean
    sender_user_id?: boolean
    sender_officer_id?: boolean
    recipient_user_id?: boolean
    recipient_officer_id?: boolean
    inbox_id?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    file_url?: boolean
    file_type?: boolean
    file_name?: boolean
    is_starred?: boolean
  }

  export type messagesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "subject" | "content" | "message_type" | "message_type_label" | "sender_user_id" | "sender_officer_id" | "recipient_user_id" | "recipient_officer_id" | "inbox_id" | "status" | "created_at" | "updated_at" | "file_url" | "file_type" | "file_name" | "is_starred", ExtArgs["result"]["messages"]>
  export type messagesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }
  export type messagesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }
  export type messagesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sender_user?: boolean | messages$sender_userArgs<ExtArgs>
    sender_officer?: boolean | messages$sender_officerArgs<ExtArgs>
    recipient_user?: boolean | messages$recipient_userArgs<ExtArgs>
    recipient_officer?: boolean | messages$recipient_officerArgs<ExtArgs>
    inbox?: boolean | messages$inboxArgs<ExtArgs>
  }

  export type $messagesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "messages"
    objects: {
      sender_user: Prisma.$usersPayload<ExtArgs> | null
      sender_officer: Prisma.$officersPayload<ExtArgs> | null
      recipient_user: Prisma.$usersPayload<ExtArgs> | null
      recipient_officer: Prisma.$officersPayload<ExtArgs> | null
      inbox: Prisma.$inboxPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      subject: string
      content: string
      message_type: string | null
      message_type_label: string | null
      sender_user_id: string | null
      sender_officer_id: string | null
      recipient_user_id: string | null
      recipient_officer_id: string | null
      inbox_id: string | null
      status: $Enums.status_messages
      created_at: Date
      updated_at: Date
      file_url: string | null
      file_type: string | null
      file_name: string | null
      is_starred: boolean
    }, ExtArgs["result"]["messages"]>
    composites: {}
  }

  type messagesGetPayload<S extends boolean | null | undefined | messagesDefaultArgs> = $Result.GetResult<Prisma.$messagesPayload, S>

  type messagesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<messagesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: MessagesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Messages.
     * @param {messagesCreateArgs} args - Arguments to create a Messages.
     * @example
     * // Create one Messages
     * const Messages = await prisma.messages.create({
     *   data: {
     *     // ... data to create a Messages
     *   }
     * })
     * 
     */
    create<T extends messagesCreateArgs>(args: SelectSubset<T, messagesCreateArgs<ExtArgs>>): Prisma__messagesClient<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Messages.
     * @param {messagesDeleteArgs} args - Arguments to delete one Messages.
     * @example
     * // Delete one Messages
     * const Messages = await prisma.messages.delete({
     *   where: {
     *     // ... filter to delete one Messages
     *   }
     * })
     * 
     */
    delete<T extends messagesDeleteArgs>(args: SelectSubset<T, messagesDeleteArgs<ExtArgs>>): Prisma__messagesClient<$Result.GetResult<Prisma.$messagesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the messages model
   */
  interface messagesFieldRefs {
    readonly id: FieldRef<"messages", 'String'>
    readonly subject: FieldRef<"messages", 'String'>
    readonly content: FieldRef<"messages", 'String'>
    readonly message_type: FieldRef<"messages", 'String'>
    readonly message_type_label: FieldRef<"messages", 'String'>
    readonly sender_user_id: FieldRef<"messages", 'String'>
    readonly sender_officer_id: FieldRef<"messages", 'String'>
    readonly recipient_user_id: FieldRef<"messages", 'String'>
    readonly recipient_officer_id: FieldRef<"messages", 'String'>
    readonly inbox_id: FieldRef<"messages", 'String'>
    readonly status: FieldRef<"messages", 'status_messages'>
    readonly created_at: FieldRef<"messages", 'DateTime'>
    readonly updated_at: FieldRef<"messages", 'DateTime'>
    readonly file_url: FieldRef<"messages", 'String'>
    readonly file_type: FieldRef<"messages", 'String'>
    readonly file_name: FieldRef<"messages", 'String'>
    readonly is_starred: FieldRef<"messages", 'Boolean'>
  }
    

  // Custom InputTypes
  /**
   * messages findUnique
   */
  export type messagesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * Filter, which messages to fetch.
     */
    where: messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * messages findUniqueOrThrow
   */
  export type messagesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * Filter, which messages to fetch.
     */
    where: messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * messages findMany
   */
  export type messagesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * Filter, which messages to fetch.
     */
    where?: messagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of messages to fetch.
     */
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing messages.
     */
    cursor?: messagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` messages.
     */
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * messages create
   */
  export type messagesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * The data needed to create a messages.
     */
    data: XOR<messagesCreateInput, messagesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * messages update
   */
  export type messagesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * The data needed to update a messages.
     */
    data: XOR<messagesUpdateInput, messagesUncheckedUpdateInput>
    /**
     * Choose, which messages to update.
     */
    where: messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * messages updateMany
   */
  export type messagesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update messages.
     */
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyInput>
    /**
     * Filter which messages to update
     */
    where?: messagesWhereInput
    /**
     * Limit how many messages to update.
     */
    limit?: number
  }

  /**
   * messages updateManyAndReturn
   */
  export type messagesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * The data used to update messages.
     */
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyInput>
    /**
     * Filter which messages to update
     */
    where?: messagesWhereInput
    /**
     * Limit how many messages to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * messages upsert
   */
  export type messagesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * The filter to search for the messages to update in case it exists.
     */
    where: messagesWhereUniqueInput
    /**
     * In case the messages found by the `where` argument doesn't exist, create a new messages with this data.
     */
    create: XOR<messagesCreateInput, messagesUncheckedCreateInput>
    /**
     * In case the messages was found with the provided `where` argument, update it with this data.
     */
    update: XOR<messagesUpdateInput, messagesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * messages delete
   */
  export type messagesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    /**
     * Filter which messages to delete.
     */
    where: messagesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * messages.sender_user
   */
  export type messages$sender_userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    where?: usersWhereInput
  }

  /**
   * messages.sender_officer
   */
  export type messages$sender_officerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
  }

  /**
   * messages.recipient_user
   */
  export type messages$recipient_userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the users
     */
    select?: usersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the users
     */
    omit?: usersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: usersInclude<ExtArgs> | null
    where?: usersWhereInput
  }

  /**
   * messages.recipient_officer
   */
  export type messages$recipient_officerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
  }

  /**
   * messages.inbox
   */
  export type messages$inboxArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    where?: inboxWhereInput
  }

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


  /**
   * Model inbox
   */

  export type AggregateInbox = {
    _count: InboxCountAggregateOutputType | null
    _avg: InboxAvgAggregateOutputType | null
    _sum: InboxSumAggregateOutputType | null
    _min: InboxMinAggregateOutputType | null
    _max: InboxMaxAggregateOutputType | null
  }

  export type InboxAvgAggregateOutputType = {
    unread_count: number | null
  }

  export type InboxSumAggregateOutputType = {
    unread_count: number | null
  }

  export type InboxMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    officer_id: string | null
    unread_count: number | null
    last_updated: Date | null
    created_at: Date | null
  }

  export type InboxMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    officer_id: string | null
    unread_count: number | null
    last_updated: Date | null
    created_at: Date | null
  }

  export type InboxCountAggregateOutputType = {
    id: number
    user_id: number
    officer_id: number
    unread_count: number
    last_updated: number
    created_at: number
    _all: number
  }


  export type InboxAvgAggregateInputType = {
    unread_count?: true
  }

  export type InboxSumAggregateInputType = {
    unread_count?: true
  }

  export type InboxMinAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    unread_count?: true
    last_updated?: true
    created_at?: true
  }

  export type InboxMaxAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    unread_count?: true
    last_updated?: true
    created_at?: true
  }

  export type InboxCountAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    unread_count?: true
    last_updated?: true
    created_at?: true
    _all?: true
  }

  export type InboxAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which inbox to aggregate.
     */
    where?: inboxWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of inboxes to fetch.
     */
    orderBy?: inboxOrderByWithRelationInput | inboxOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: inboxWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` inboxes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` inboxes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned inboxes
    **/
    _count?: true | InboxCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: InboxAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: InboxSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: InboxMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: InboxMaxAggregateInputType
  }

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




  export type inboxGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: inboxWhereInput
    orderBy?: inboxOrderByWithAggregationInput | inboxOrderByWithAggregationInput[]
    by: InboxScalarFieldEnum[] | InboxScalarFieldEnum
    having?: inboxScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: InboxCountAggregateInputType | true
    _avg?: InboxAvgAggregateInputType
    _sum?: InboxSumAggregateInputType
    _min?: InboxMinAggregateInputType
    _max?: InboxMaxAggregateInputType
  }

  export type InboxGroupByOutputType = {
    id: string
    user_id: string
    officer_id: string
    unread_count: number
    last_updated: Date
    created_at: Date
    _count: InboxCountAggregateOutputType | null
    _avg: InboxAvgAggregateOutputType | null
    _sum: InboxSumAggregateOutputType | null
    _min: InboxMinAggregateOutputType | null
    _max: InboxMaxAggregateOutputType | null
  }

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


  export type inboxSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    unread_count?: boolean
    last_updated?: boolean
    created_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
    messages?: boolean | inbox$messagesArgs<ExtArgs>
    _count?: boolean | InboxCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["inbox"]>

  export type inboxSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    unread_count?: boolean
    last_updated?: boolean
    created_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["inbox"]>

  export type inboxSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    unread_count?: boolean
    last_updated?: boolean
    created_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["inbox"]>

  export type inboxSelectScalar = {
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    unread_count?: boolean
    last_updated?: boolean
    created_at?: boolean
  }

  export type inboxOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "officer_id" | "unread_count" | "last_updated" | "created_at", ExtArgs["result"]["inbox"]>
  export type inboxInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
    messages?: boolean | inbox$messagesArgs<ExtArgs>
    _count?: boolean | InboxCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type inboxIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
  }
  export type inboxIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
    officer?: boolean | officersDefaultArgs<ExtArgs>
  }

  export type $inboxPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "inbox"
    objects: {
      user: Prisma.$usersPayload<ExtArgs>
      officer: Prisma.$officersPayload<ExtArgs>
      messages: Prisma.$messagesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      officer_id: string
      unread_count: number
      last_updated: Date
      created_at: Date
    }, ExtArgs["result"]["inbox"]>
    composites: {}
  }

  type inboxGetPayload<S extends boolean | null | undefined | inboxDefaultArgs> = $Result.GetResult<Prisma.$inboxPayload, S>

  type inboxCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<inboxFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: InboxCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Inbox.
     * @param {inboxCreateArgs} args - Arguments to create a Inbox.
     * @example
     * // Create one Inbox
     * const Inbox = await prisma.inbox.create({
     *   data: {
     *     // ... data to create a Inbox
     *   }
     * })
     * 
     */
    create<T extends inboxCreateArgs>(args: SelectSubset<T, inboxCreateArgs<ExtArgs>>): Prisma__inboxClient<$Result.GetResult<Prisma.$inboxPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Inbox.
     * @param {inboxDeleteArgs} args - Arguments to delete one Inbox.
     * @example
     * // Delete one Inbox
     * const Inbox = await prisma.inbox.delete({
     *   where: {
     *     // ... filter to delete one Inbox
     *   }
     * })
     * 
     */
    delete<T extends inboxDeleteArgs>(args: SelectSubset<T, inboxDeleteArgs<ExtArgs>>): Prisma__inboxClient<$Result.GetResult<Prisma.$inboxPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the inbox model
   */
  interface inboxFieldRefs {
    readonly id: FieldRef<"inbox", 'String'>
    readonly user_id: FieldRef<"inbox", 'String'>
    readonly officer_id: FieldRef<"inbox", 'String'>
    readonly unread_count: FieldRef<"inbox", 'Int'>
    readonly last_updated: FieldRef<"inbox", 'DateTime'>
    readonly created_at: FieldRef<"inbox", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * inbox findUnique
   */
  export type inboxFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter, which inbox to fetch.
     */
    where: inboxWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox findUniqueOrThrow
   */
  export type inboxFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter, which inbox to fetch.
     */
    where: inboxWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox findFirst
   */
  export type inboxFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter, which inbox to fetch.
     */
    where?: inboxWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of inboxes to fetch.
     */
    orderBy?: inboxOrderByWithRelationInput | inboxOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for inboxes.
     */
    cursor?: inboxWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` inboxes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` inboxes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of inboxes.
     */
    distinct?: InboxScalarFieldEnum | InboxScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox findFirstOrThrow
   */
  export type inboxFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter, which inbox to fetch.
     */
    where?: inboxWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of inboxes to fetch.
     */
    orderBy?: inboxOrderByWithRelationInput | inboxOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for inboxes.
     */
    cursor?: inboxWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` inboxes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` inboxes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of inboxes.
     */
    distinct?: InboxScalarFieldEnum | InboxScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox findMany
   */
  export type inboxFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter, which inboxes to fetch.
     */
    where?: inboxWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of inboxes to fetch.
     */
    orderBy?: inboxOrderByWithRelationInput | inboxOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing inboxes.
     */
    cursor?: inboxWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` inboxes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` inboxes.
     */
    skip?: number
    distinct?: InboxScalarFieldEnum | InboxScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox create
   */
  export type inboxCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * The data needed to create a inbox.
     */
    data: XOR<inboxCreateInput, inboxUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * inbox createManyAndReturn
   */
  export type inboxCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * The data used to create many inboxes.
     */
    data: inboxCreateManyInput | inboxCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * inbox update
   */
  export type inboxUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * The data needed to update a inbox.
     */
    data: XOR<inboxUpdateInput, inboxUncheckedUpdateInput>
    /**
     * Choose, which inbox to update.
     */
    where: inboxWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox updateMany
   */
  export type inboxUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update inboxes.
     */
    data: XOR<inboxUpdateManyMutationInput, inboxUncheckedUpdateManyInput>
    /**
     * Filter which inboxes to update
     */
    where?: inboxWhereInput
    /**
     * Limit how many inboxes to update.
     */
    limit?: number
  }

  /**
   * inbox updateManyAndReturn
   */
  export type inboxUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * The data used to update inboxes.
     */
    data: XOR<inboxUpdateManyMutationInput, inboxUncheckedUpdateManyInput>
    /**
     * Filter which inboxes to update
     */
    where?: inboxWhereInput
    /**
     * Limit how many inboxes to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * inbox upsert
   */
  export type inboxUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * The filter to search for the inbox to update in case it exists.
     */
    where: inboxWhereUniqueInput
    /**
     * In case the inbox found by the `where` argument doesn't exist, create a new inbox with this data.
     */
    create: XOR<inboxCreateInput, inboxUncheckedCreateInput>
    /**
     * In case the inbox was found with the provided `where` argument, update it with this data.
     */
    update: XOR<inboxUpdateInput, inboxUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * inbox delete
   */
  export type inboxDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the inbox
     */
    select?: inboxSelect<ExtArgs> | null
    /**
     * Omit specific fields from the inbox
     */
    omit?: inboxOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: inboxInclude<ExtArgs> | null
    /**
     * Filter which inbox to delete.
     */
    where: inboxWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * inbox.messages
   */
  export type inbox$messagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the messages
     */
    select?: messagesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the messages
     */
    omit?: messagesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: messagesInclude<ExtArgs> | null
    where?: messagesWhereInput
    orderBy?: messagesOrderByWithRelationInput | messagesOrderByWithRelationInput[]
    cursor?: messagesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }

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


  /**
   * Model logs
   */

  export type AggregateLogs = {
    _count: LogsCountAggregateOutputType | null
    _min: LogsMinAggregateOutputType | null
    _max: LogsMaxAggregateOutputType | null
  }

  export type LogsMinAggregateOutputType = {
    id: string | null
    action: string | null
    entity: string | null
    entity_id: string | null
    user_id: string | null
    ip_address: string | null
    user_agent: string | null
    created_at: Date | null
  }

  export type LogsMaxAggregateOutputType = {
    id: string | null
    action: string | null
    entity: string | null
    entity_id: string | null
    user_id: string | null
    ip_address: string | null
    user_agent: string | null
    created_at: Date | null
  }

  export type LogsCountAggregateOutputType = {
    id: number
    action: number
    entity: number
    entity_id: number
    changes: number
    user_id: number
    ip_address: number
    user_agent: number
    created_at: number
    _all: number
  }


  export type LogsMinAggregateInputType = {
    id?: true
    action?: true
    entity?: true
    entity_id?: true
    user_id?: true
    ip_address?: true
    user_agent?: true
    created_at?: true
  }

  export type LogsMaxAggregateInputType = {
    id?: true
    action?: true
    entity?: true
    entity_id?: true
    user_id?: true
    ip_address?: true
    user_agent?: true
    created_at?: true
  }

  export type LogsCountAggregateInputType = {
    id?: true
    action?: true
    entity?: true
    entity_id?: true
    changes?: true
    user_id?: true
    ip_address?: true
    user_agent?: true
    created_at?: true
    _all?: true
  }

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

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




  export type logsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: logsWhereInput
    orderBy?: logsOrderByWithAggregationInput | logsOrderByWithAggregationInput[]
    by: LogsScalarFieldEnum[] | LogsScalarFieldEnum
    having?: logsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LogsCountAggregateInputType | true
    _min?: LogsMinAggregateInputType
    _max?: LogsMaxAggregateInputType
  }

  export type LogsGroupByOutputType = {
    id: string
    action: string
    entity: string
    entity_id: string | null
    changes: JsonValue | null
    user_id: string | null
    ip_address: string | null
    user_agent: string | null
    created_at: Date
    _count: LogsCountAggregateOutputType | null
    _min: LogsMinAggregateOutputType | null
    _max: LogsMaxAggregateOutputType | null
  }

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


  export type logsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    entity?: boolean
    entity_id?: boolean
    changes?: boolean
    user_id?: boolean
    ip_address?: boolean
    user_agent?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["logs"]>

  export type logsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    entity?: boolean
    entity_id?: boolean
    changes?: boolean
    user_id?: boolean
    ip_address?: boolean
    user_agent?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["logs"]>

  export type logsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    action?: boolean
    entity?: boolean
    entity_id?: boolean
    changes?: boolean
    user_id?: boolean
    ip_address?: boolean
    user_agent?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["logs"]>

  export type logsSelectScalar = {
    id?: boolean
    action?: boolean
    entity?: boolean
    entity_id?: boolean
    changes?: boolean
    user_id?: boolean
    ip_address?: boolean
    user_agent?: boolean
    created_at?: boolean
  }

  export type logsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "action" | "entity" | "entity_id" | "changes" | "user_id" | "ip_address" | "user_agent" | "created_at", ExtArgs["result"]["logs"]>

  export type $logsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "logs"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      action: string
      entity: string
      entity_id: string | null
      changes: Prisma.JsonValue | null
      user_id: string | null
      ip_address: string | null
      user_agent: string | null
      created_at: Date
    }, ExtArgs["result"]["logs"]>
    composites: {}
  }

  type logsGetPayload<S extends boolean | null | undefined | logsDefaultArgs> = $Result.GetResult<Prisma.$logsPayload, S>

  type logsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<logsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: LogsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Logs.
     * @param {logsCreateArgs} args - Arguments to create a Logs.
     * @example
     * // Create one Logs
     * const Logs = await prisma.logs.create({
     *   data: {
     *     // ... data to create a Logs
     *   }
     * })
     * 
     */
    create<T extends logsCreateArgs>(args: SelectSubset<T, logsCreateArgs<ExtArgs>>): Prisma__logsClient<$Result.GetResult<Prisma.$logsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Logs.
     * @param {logsDeleteArgs} args - Arguments to delete one Logs.
     * @example
     * // Delete one Logs
     * const Logs = await prisma.logs.delete({
     *   where: {
     *     // ... filter to delete one Logs
     *   }
     * })
     * 
     */
    delete<T extends logsDeleteArgs>(args: SelectSubset<T, logsDeleteArgs<ExtArgs>>): Prisma__logsClient<$Result.GetResult<Prisma.$logsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the logs model
   */
  interface logsFieldRefs {
    readonly id: FieldRef<"logs", 'String'>
    readonly action: FieldRef<"logs", 'String'>
    readonly entity: FieldRef<"logs", 'String'>
    readonly entity_id: FieldRef<"logs", 'String'>
    readonly changes: FieldRef<"logs", 'Json'>
    readonly user_id: FieldRef<"logs", 'String'>
    readonly ip_address: FieldRef<"logs", 'String'>
    readonly user_agent: FieldRef<"logs", 'String'>
    readonly created_at: FieldRef<"logs", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * logs findUnique
   */
  export type logsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter, which logs to fetch.
     */
    where: logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs findUniqueOrThrow
   */
  export type logsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter, which logs to fetch.
     */
    where: logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs findFirst
   */
  export type logsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter, which logs to fetch.
     */
    where?: logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of logs to fetch.
     */
    orderBy?: logsOrderByWithRelationInput | logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for logs.
     */
    cursor?: logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` logs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of logs.
     */
    distinct?: LogsScalarFieldEnum | LogsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs findFirstOrThrow
   */
  export type logsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter, which logs to fetch.
     */
    where?: logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of logs to fetch.
     */
    orderBy?: logsOrderByWithRelationInput | logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for logs.
     */
    cursor?: logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` logs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of logs.
     */
    distinct?: LogsScalarFieldEnum | LogsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs findMany
   */
  export type logsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter, which logs to fetch.
     */
    where?: logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of logs to fetch.
     */
    orderBy?: logsOrderByWithRelationInput | logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing logs.
     */
    cursor?: logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` logs.
     */
    skip?: number
    distinct?: LogsScalarFieldEnum | LogsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs create
   */
  export type logsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * The data needed to create a logs.
     */
    data: XOR<logsCreateInput, logsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * logs createManyAndReturn
   */
  export type logsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * The data used to create many logs.
     */
    data: logsCreateManyInput | logsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * logs update
   */
  export type logsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * The data needed to update a logs.
     */
    data: XOR<logsUpdateInput, logsUncheckedUpdateInput>
    /**
     * Choose, which logs to update.
     */
    where: logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs updateMany
   */
  export type logsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update logs.
     */
    data: XOR<logsUpdateManyMutationInput, logsUncheckedUpdateManyInput>
    /**
     * Filter which logs to update
     */
    where?: logsWhereInput
    /**
     * Limit how many logs to update.
     */
    limit?: number
  }

  /**
   * logs updateManyAndReturn
   */
  export type logsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * The data used to update logs.
     */
    data: XOR<logsUpdateManyMutationInput, logsUncheckedUpdateManyInput>
    /**
     * Filter which logs to update
     */
    where?: logsWhereInput
    /**
     * Limit how many logs to update.
     */
    limit?: number
  }

  /**
   * logs upsert
   */
  export type logsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * The filter to search for the logs to update in case it exists.
     */
    where: logsWhereUniqueInput
    /**
     * In case the logs found by the `where` argument doesn't exist, create a new logs with this data.
     */
    create: XOR<logsCreateInput, logsUncheckedCreateInput>
    /**
     * In case the logs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<logsUpdateInput, logsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * logs delete
   */
  export type logsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
    /**
     * Filter which logs to delete.
     */
    where: logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * logs without action
   */
  export type logsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the logs
     */
    select?: logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the logs
     */
    omit?: logsOmit<ExtArgs> | null
  }


  /**
   * Model panic_button_logs
   */

  export type AggregatePanic_button_logs = {
    _count: Panic_button_logsCountAggregateOutputType | null
    _min: Panic_button_logsMinAggregateOutputType | null
    _max: Panic_button_logsMaxAggregateOutputType | null
  }

  export type Panic_button_logsMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    officer_id: string | null
    incident_logs_id: string | null
    timestamp: Date | null
  }

  export type Panic_button_logsMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    officer_id: string | null
    incident_logs_id: string | null
    timestamp: Date | null
  }

  export type Panic_button_logsCountAggregateOutputType = {
    id: number
    user_id: number
    officer_id: number
    incident_logs_id: number
    timestamp: number
    _all: number
  }


  export type Panic_button_logsMinAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    incident_logs_id?: true
    timestamp?: true
  }

  export type Panic_button_logsMaxAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    incident_logs_id?: true
    timestamp?: true
  }

  export type Panic_button_logsCountAggregateInputType = {
    id?: true
    user_id?: true
    officer_id?: true
    incident_logs_id?: true
    timestamp?: true
    _all?: true
  }

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

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




  export type panic_button_logsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: panic_button_logsWhereInput
    orderBy?: panic_button_logsOrderByWithAggregationInput | panic_button_logsOrderByWithAggregationInput[]
    by: Panic_button_logsScalarFieldEnum[] | Panic_button_logsScalarFieldEnum
    having?: panic_button_logsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Panic_button_logsCountAggregateInputType | true
    _min?: Panic_button_logsMinAggregateInputType
    _max?: Panic_button_logsMaxAggregateInputType
  }

  export type Panic_button_logsGroupByOutputType = {
    id: string
    user_id: string
    officer_id: string | null
    incident_logs_id: string
    timestamp: Date
    _count: Panic_button_logsCountAggregateOutputType | null
    _min: Panic_button_logsMinAggregateOutputType | null
    _max: Panic_button_logsMaxAggregateOutputType | null
  }

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


  export type panic_button_logsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    incident_logs_id?: boolean
    timestamp?: boolean
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["panic_button_logs"]>

  export type panic_button_logsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    incident_logs_id?: boolean
    timestamp?: boolean
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["panic_button_logs"]>

  export type panic_button_logsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    incident_logs_id?: boolean
    timestamp?: boolean
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["panic_button_logs"]>

  export type panic_button_logsSelectScalar = {
    id?: boolean
    user_id?: boolean
    officer_id?: boolean
    incident_logs_id?: boolean
    timestamp?: boolean
  }

  export type panic_button_logsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "officer_id" | "incident_logs_id" | "timestamp", ExtArgs["result"]["panic_button_logs"]>
  export type panic_button_logsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type panic_button_logsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type panic_button_logsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    incidents?: boolean | incident_logsDefaultArgs<ExtArgs>
    officers?: boolean | panic_button_logs$officersArgs<ExtArgs>
    users?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $panic_button_logsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "panic_button_logs"
    objects: {
      incidents: Prisma.$incident_logsPayload<ExtArgs>
      officers: Prisma.$officersPayload<ExtArgs> | null
      users: Prisma.$usersPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      officer_id: string | null
      incident_logs_id: string
      timestamp: Date
    }, ExtArgs["result"]["panic_button_logs"]>
    composites: {}
  }

  type panic_button_logsGetPayload<S extends boolean | null | undefined | panic_button_logsDefaultArgs> = $Result.GetResult<Prisma.$panic_button_logsPayload, S>

  type panic_button_logsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<panic_button_logsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Panic_button_logsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Panic_button_logs.
     * @param {panic_button_logsCreateArgs} args - Arguments to create a Panic_button_logs.
     * @example
     * // Create one Panic_button_logs
     * const Panic_button_logs = await prisma.panic_button_logs.create({
     *   data: {
     *     // ... data to create a Panic_button_logs
     *   }
     * })
     * 
     */
    create<T extends panic_button_logsCreateArgs>(args: SelectSubset<T, panic_button_logsCreateArgs<ExtArgs>>): Prisma__panic_button_logsClient<$Result.GetResult<Prisma.$panic_button_logsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Panic_button_logs.
     * @param {panic_button_logsDeleteArgs} args - Arguments to delete one Panic_button_logs.
     * @example
     * // Delete one Panic_button_logs
     * const Panic_button_logs = await prisma.panic_button_logs.delete({
     *   where: {
     *     // ... filter to delete one Panic_button_logs
     *   }
     * })
     * 
     */
    delete<T extends panic_button_logsDeleteArgs>(args: SelectSubset<T, panic_button_logsDeleteArgs<ExtArgs>>): Prisma__panic_button_logsClient<$Result.GetResult<Prisma.$panic_button_logsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the panic_button_logs model
   */
  interface panic_button_logsFieldRefs {
    readonly id: FieldRef<"panic_button_logs", 'String'>
    readonly user_id: FieldRef<"panic_button_logs", 'String'>
    readonly officer_id: FieldRef<"panic_button_logs", 'String'>
    readonly incident_logs_id: FieldRef<"panic_button_logs", 'String'>
    readonly timestamp: FieldRef<"panic_button_logs", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * panic_button_logs findUnique
   */
  export type panic_button_logsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * Filter, which panic_button_logs to fetch.
     */
    where: panic_button_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * panic_button_logs findUniqueOrThrow
   */
  export type panic_button_logsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * Filter, which panic_button_logs to fetch.
     */
    where: panic_button_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * panic_button_logs findMany
   */
  export type panic_button_logsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * Filter, which panic_button_logs to fetch.
     */
    where?: panic_button_logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of panic_button_logs to fetch.
     */
    orderBy?: panic_button_logsOrderByWithRelationInput | panic_button_logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing panic_button_logs.
     */
    cursor?: panic_button_logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` panic_button_logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` panic_button_logs.
     */
    skip?: number
    distinct?: Panic_button_logsScalarFieldEnum | Panic_button_logsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * panic_button_logs create
   */
  export type panic_button_logsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * The data needed to create a panic_button_logs.
     */
    data: XOR<panic_button_logsCreateInput, panic_button_logsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * panic_button_logs update
   */
  export type panic_button_logsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * The data needed to update a panic_button_logs.
     */
    data: XOR<panic_button_logsUpdateInput, panic_button_logsUncheckedUpdateInput>
    /**
     * Choose, which panic_button_logs to update.
     */
    where: panic_button_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * panic_button_logs updateMany
   */
  export type panic_button_logsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update panic_button_logs.
     */
    data: XOR<panic_button_logsUpdateManyMutationInput, panic_button_logsUncheckedUpdateManyInput>
    /**
     * Filter which panic_button_logs to update
     */
    where?: panic_button_logsWhereInput
    /**
     * Limit how many panic_button_logs to update.
     */
    limit?: number
  }

  /**
   * panic_button_logs updateManyAndReturn
   */
  export type panic_button_logsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * The data used to update panic_button_logs.
     */
    data: XOR<panic_button_logsUpdateManyMutationInput, panic_button_logsUncheckedUpdateManyInput>
    /**
     * Filter which panic_button_logs to update
     */
    where?: panic_button_logsWhereInput
    /**
     * Limit how many panic_button_logs to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * panic_button_logs upsert
   */
  export type panic_button_logsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * The filter to search for the panic_button_logs to update in case it exists.
     */
    where: panic_button_logsWhereUniqueInput
    /**
     * In case the panic_button_logs found by the `where` argument doesn't exist, create a new panic_button_logs with this data.
     */
    create: XOR<panic_button_logsCreateInput, panic_button_logsUncheckedCreateInput>
    /**
     * In case the panic_button_logs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<panic_button_logsUpdateInput, panic_button_logsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * panic_button_logs delete
   */
  export type panic_button_logsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the panic_button_logs
     */
    select?: panic_button_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the panic_button_logs
     */
    omit?: panic_button_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: panic_button_logsInclude<ExtArgs> | null
    /**
     * Filter which panic_button_logs to delete.
     */
    where: panic_button_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

  /**
   * panic_button_logs.officers
   */
  export type panic_button_logs$officersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the officers
     */
    select?: officersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the officers
     */
    omit?: officersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: officersInclude<ExtArgs> | null
    where?: officersWhereInput
  }

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


  /**
   * Model location_logs
   */

  export type AggregateLocation_logs = {
    _count: Location_logsCountAggregateOutputType | null
    _avg: Location_logsAvgAggregateOutputType | null
    _sum: Location_logsSumAggregateOutputType | null
    _min: Location_logsMinAggregateOutputType | null
    _max: Location_logsMaxAggregateOutputType | null
  }

  export type Location_logsAvgAggregateOutputType = {
    latitude: number | null
    longitude: number | null
  }

  export type Location_logsSumAggregateOutputType = {
    latitude: number | null
    longitude: number | null
  }

  export type Location_logsMinAggregateOutputType = {
    id: string | null
    location_id: string | null
    latitude: number | null
    longitude: number | null
    timestamp: Date | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Location_logsMaxAggregateOutputType = {
    id: string | null
    location_id: string | null
    latitude: number | null
    longitude: number | null
    timestamp: Date | null
    description: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type Location_logsCountAggregateOutputType = {
    id: number
    location_id: number
    latitude: number
    longitude: number
    timestamp: number
    description: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type Location_logsAvgAggregateInputType = {
    latitude?: true
    longitude?: true
  }

  export type Location_logsSumAggregateInputType = {
    latitude?: true
    longitude?: true
  }

  export type Location_logsMinAggregateInputType = {
    id?: true
    location_id?: true
    latitude?: true
    longitude?: true
    timestamp?: true
    description?: true
    created_at?: true
    updated_at?: true
  }

  export type Location_logsMaxAggregateInputType = {
    id?: true
    location_id?: true
    latitude?: true
    longitude?: true
    timestamp?: true
    description?: true
    created_at?: true
    updated_at?: true
  }

  export type Location_logsCountAggregateInputType = {
    id?: true
    location_id?: true
    latitude?: true
    longitude?: true
    timestamp?: true
    description?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type Location_logsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which location_logs to aggregate.
     */
    where?: location_logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of location_logs to fetch.
     */
    orderBy?: location_logsOrderByWithRelationInput | location_logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: location_logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` location_logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` location_logs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned location_logs
    **/
    _count?: true | Location_logsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Location_logsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Location_logsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Location_logsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Location_logsMaxAggregateInputType
  }

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




  export type location_logsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: location_logsWhereInput
    orderBy?: location_logsOrderByWithAggregationInput | location_logsOrderByWithAggregationInput[]
    by: Location_logsScalarFieldEnum[] | Location_logsScalarFieldEnum
    having?: location_logsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Location_logsCountAggregateInputType | true
    _avg?: Location_logsAvgAggregateInputType
    _sum?: Location_logsSumAggregateInputType
    _min?: Location_logsMinAggregateInputType
    _max?: Location_logsMaxAggregateInputType
  }

  export type Location_logsGroupByOutputType = {
    id: string
    location_id: string
    latitude: number
    longitude: number
    timestamp: Date
    description: string | null
    created_at: Date
    updated_at: Date
    _count: Location_logsCountAggregateOutputType | null
    _avg: Location_logsAvgAggregateOutputType | null
    _sum: Location_logsSumAggregateOutputType | null
    _min: Location_logsMinAggregateOutputType | null
    _max: Location_logsMaxAggregateOutputType | null
  }

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


  export type location_logsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    location_id?: boolean
    latitude?: boolean
    longitude?: boolean
    timestamp?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    location?: boolean | locationsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["location_logs"]>


  export type location_logsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    location_id?: boolean
    latitude?: boolean
    longitude?: boolean
    timestamp?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
    location?: boolean | locationsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["location_logs"]>

  export type location_logsSelectScalar = {
    id?: boolean
    location_id?: boolean
    latitude?: boolean
    longitude?: boolean
    timestamp?: boolean
    description?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type location_logsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "location_id" | "latitude" | "longitude" | "timestamp" | "description" | "created_at" | "updated_at", ExtArgs["result"]["location_logs"]>
  export type location_logsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    location?: boolean | locationsDefaultArgs<ExtArgs>
  }
  export type location_logsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    location?: boolean | locationsDefaultArgs<ExtArgs>
  }

  export type $location_logsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "location_logs"
    objects: {
      location: Prisma.$locationsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      location_id: string
      latitude: number
      longitude: number
      timestamp: Date
      description: string | null
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["location_logs"]>
    composites: {}
  }

  type location_logsGetPayload<S extends boolean | null | undefined | location_logsDefaultArgs> = $Result.GetResult<Prisma.$location_logsPayload, S>

  type location_logsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<location_logsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Location_logsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Delete a Location_logs.
     * @param {location_logsDeleteArgs} args - Arguments to delete one Location_logs.
     * @example
     * // Delete one Location_logs
     * const Location_logs = await prisma.location_logs.delete({
     *   where: {
     *     // ... filter to delete one Location_logs
     *   }
     * })
     * 
     */
    delete<T extends location_logsDeleteArgs>(args: SelectSubset<T, location_logsDeleteArgs<ExtArgs>>): Prisma__location_logsClient<$Result.GetResult<Prisma.$location_logsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

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




  /**
   * Fields of the location_logs model
   */
  interface location_logsFieldRefs {
    readonly id: FieldRef<"location_logs", 'String'>
    readonly location_id: FieldRef<"location_logs", 'String'>
    readonly latitude: FieldRef<"location_logs", 'Float'>
    readonly longitude: FieldRef<"location_logs", 'Float'>
    readonly timestamp: FieldRef<"location_logs", 'DateTime'>
    readonly description: FieldRef<"location_logs", 'String'>
    readonly created_at: FieldRef<"location_logs", 'DateTime'>
    readonly updated_at: FieldRef<"location_logs", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * location_logs findUnique
   */
  export type location_logsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    /**
     * Filter, which location_logs to fetch.
     */
    where: location_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * location_logs findUniqueOrThrow
   */
  export type location_logsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    /**
     * Filter, which location_logs to fetch.
     */
    where: location_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * location_logs findMany
   */
  export type location_logsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    /**
     * Filter, which location_logs to fetch.
     */
    where?: location_logsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of location_logs to fetch.
     */
    orderBy?: location_logsOrderByWithRelationInput | location_logsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing location_logs.
     */
    cursor?: location_logsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` location_logs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` location_logs.
     */
    skip?: number
    distinct?: Location_logsScalarFieldEnum | Location_logsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * location_logs update
   */
  export type location_logsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    /**
     * The data needed to update a location_logs.
     */
    data: XOR<location_logsUpdateInput, location_logsUncheckedUpdateInput>
    /**
     * Choose, which location_logs to update.
     */
    where: location_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * location_logs updateMany
   */
  export type location_logsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update location_logs.
     */
    data: XOR<location_logsUpdateManyMutationInput, location_logsUncheckedUpdateManyInput>
    /**
     * Filter which location_logs to update
     */
    where?: location_logsWhereInput
    /**
     * Limit how many location_logs to update.
     */
    limit?: number
  }

  /**
   * location_logs updateManyAndReturn
   */
  export type location_logsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * The data used to update location_logs.
     */
    data: XOR<location_logsUpdateManyMutationInput, location_logsUncheckedUpdateManyInput>
    /**
     * Filter which location_logs to update
     */
    where?: location_logsWhereInput
    /**
     * Limit how many location_logs to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * location_logs delete
   */
  export type location_logsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the location_logs
     */
    select?: location_logsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the location_logs
     */
    omit?: location_logsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: location_logsInclude<ExtArgs> | null
    /**
     * Filter which location_logs to delete.
     */
    where: location_logsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model district_clusters
   */

  export type AggregateDistrict_clusters = {
    _count: District_clustersCountAggregateOutputType | null
    _avg: District_clustersAvgAggregateOutputType | null
    _sum: District_clustersSumAggregateOutputType | null
    _min: District_clustersMinAggregateOutputType | null
    _max: District_clustersMaxAggregateOutputType | null
  }

  export type District_clustersAvgAggregateOutputType = {
    year: number | null
    month: number | null
    total_crimes: number | null
    population_density: number | null
    unemployment_rate: number | null
    crime_score: number | null
    density_score: number | null
    unemployment_score: number | null
    cluster_score: number | null
    member_count: number | null
    update_count: number | null
  }

  export type District_clustersSumAggregateOutputType = {
    year: number | null
    month: number | null
    total_crimes: number | null
    population_density: number | null
    unemployment_rate: number | null
    crime_score: number | null
    density_score: number | null
    unemployment_score: number | null
    cluster_score: number | null
    member_count: number | null
    update_count: number | null
  }

  export type District_clustersMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    year: number | null
    month: number | null
    risk_level: $Enums.crime_rates | null
    total_crimes: number | null
    population_density: number | null
    unemployment_rate: number | null
    crime_score: number | null
    density_score: number | null
    unemployment_score: number | null
    cluster_score: number | null
    member_count: number | null
    last_update_type: string | null
    update_count: number | null
    needs_recompute: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type District_clustersMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    year: number | null
    month: number | null
    risk_level: $Enums.crime_rates | null
    total_crimes: number | null
    population_density: number | null
    unemployment_rate: number | null
    crime_score: number | null
    density_score: number | null
    unemployment_score: number | null
    cluster_score: number | null
    member_count: number | null
    last_update_type: string | null
    update_count: number | null
    needs_recompute: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type District_clustersCountAggregateOutputType = {
    id: number
    district_id: number
    year: number
    month: number
    risk_level: number
    total_crimes: number
    population_density: number
    unemployment_rate: number
    crime_score: number
    density_score: number
    unemployment_score: number
    cluster_score: number
    centroid_features: number
    member_count: number
    last_update_type: number
    update_count: number
    needs_recompute: number
    incidents_data: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type District_clustersAvgAggregateInputType = {
    year?: true
    month?: true
    total_crimes?: true
    population_density?: true
    unemployment_rate?: true
    crime_score?: true
    density_score?: true
    unemployment_score?: true
    cluster_score?: true
    member_count?: true
    update_count?: true
  }

  export type District_clustersSumAggregateInputType = {
    year?: true
    month?: true
    total_crimes?: true
    population_density?: true
    unemployment_rate?: true
    crime_score?: true
    density_score?: true
    unemployment_score?: true
    cluster_score?: true
    member_count?: true
    update_count?: true
  }

  export type District_clustersMinAggregateInputType = {
    id?: true
    district_id?: true
    year?: true
    month?: true
    risk_level?: true
    total_crimes?: true
    population_density?: true
    unemployment_rate?: true
    crime_score?: true
    density_score?: true
    unemployment_score?: true
    cluster_score?: true
    member_count?: true
    last_update_type?: true
    update_count?: true
    needs_recompute?: true
    created_at?: true
    updated_at?: true
  }

  export type District_clustersMaxAggregateInputType = {
    id?: true
    district_id?: true
    year?: true
    month?: true
    risk_level?: true
    total_crimes?: true
    population_density?: true
    unemployment_rate?: true
    crime_score?: true
    density_score?: true
    unemployment_score?: true
    cluster_score?: true
    member_count?: true
    last_update_type?: true
    update_count?: true
    needs_recompute?: true
    created_at?: true
    updated_at?: true
  }

  export type District_clustersCountAggregateInputType = {
    id?: true
    district_id?: true
    year?: true
    month?: true
    risk_level?: true
    total_crimes?: true
    population_density?: true
    unemployment_rate?: true
    crime_score?: true
    density_score?: true
    unemployment_score?: true
    cluster_score?: true
    centroid_features?: true
    member_count?: true
    last_update_type?: true
    update_count?: true
    needs_recompute?: true
    incidents_data?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type District_clustersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which district_clusters to aggregate.
     */
    where?: district_clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of district_clusters to fetch.
     */
    orderBy?: district_clustersOrderByWithRelationInput | district_clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: district_clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` district_clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` district_clusters.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned district_clusters
    **/
    _count?: true | District_clustersCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: District_clustersAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: District_clustersSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: District_clustersMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: District_clustersMaxAggregateInputType
  }

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




  export type district_clustersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: district_clustersWhereInput
    orderBy?: district_clustersOrderByWithAggregationInput | district_clustersOrderByWithAggregationInput[]
    by: District_clustersScalarFieldEnum[] | District_clustersScalarFieldEnum
    having?: district_clustersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: District_clustersCountAggregateInputType | true
    _avg?: District_clustersAvgAggregateInputType
    _sum?: District_clustersSumAggregateInputType
    _min?: District_clustersMinAggregateInputType
    _max?: District_clustersMaxAggregateInputType
  }

  export type District_clustersGroupByOutputType = {
    id: string
    district_id: string
    year: number
    month: number | null
    risk_level: $Enums.crime_rates
    total_crimes: number
    population_density: number
    unemployment_rate: number
    crime_score: number
    density_score: number
    unemployment_score: number
    cluster_score: number
    centroid_features: JsonValue | null
    member_count: number
    last_update_type: string
    update_count: number
    needs_recompute: boolean
    incidents_data: JsonValue | null
    created_at: Date
    updated_at: Date
    _count: District_clustersCountAggregateOutputType | null
    _avg: District_clustersAvgAggregateOutputType | null
    _sum: District_clustersSumAggregateOutputType | null
    _min: District_clustersMinAggregateOutputType | null
    _max: District_clustersMaxAggregateOutputType | null
  }

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


  export type district_clustersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    year?: boolean
    month?: boolean
    risk_level?: boolean
    total_crimes?: boolean
    population_density?: boolean
    unemployment_rate?: boolean
    crime_score?: boolean
    density_score?: boolean
    unemployment_score?: boolean
    cluster_score?: boolean
    centroid_features?: boolean
    member_count?: boolean
    last_update_type?: boolean
    update_count?: boolean
    needs_recompute?: boolean
    incidents_data?: boolean
    created_at?: boolean
    updated_at?: boolean
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["district_clusters"]>

  export type district_clustersSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    year?: boolean
    month?: boolean
    risk_level?: boolean
    total_crimes?: boolean
    population_density?: boolean
    unemployment_rate?: boolean
    crime_score?: boolean
    density_score?: boolean
    unemployment_score?: boolean
    cluster_score?: boolean
    centroid_features?: boolean
    member_count?: boolean
    last_update_type?: boolean
    update_count?: boolean
    needs_recompute?: boolean
    incidents_data?: boolean
    created_at?: boolean
    updated_at?: boolean
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["district_clusters"]>

  export type district_clustersSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    year?: boolean
    month?: boolean
    risk_level?: boolean
    total_crimes?: boolean
    population_density?: boolean
    unemployment_rate?: boolean
    crime_score?: boolean
    density_score?: boolean
    unemployment_score?: boolean
    cluster_score?: boolean
    centroid_features?: boolean
    member_count?: boolean
    last_update_type?: boolean
    update_count?: boolean
    needs_recompute?: boolean
    incidents_data?: boolean
    created_at?: boolean
    updated_at?: boolean
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["district_clusters"]>

  export type district_clustersSelectScalar = {
    id?: boolean
    district_id?: boolean
    year?: boolean
    month?: boolean
    risk_level?: boolean
    total_crimes?: boolean
    population_density?: boolean
    unemployment_rate?: boolean
    crime_score?: boolean
    density_score?: boolean
    unemployment_score?: boolean
    cluster_score?: boolean
    centroid_features?: boolean
    member_count?: boolean
    last_update_type?: boolean
    update_count?: boolean
    needs_recompute?: boolean
    incidents_data?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type district_clustersOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "year" | "month" | "risk_level" | "total_crimes" | "population_density" | "unemployment_rate" | "crime_score" | "density_score" | "unemployment_score" | "cluster_score" | "centroid_features" | "member_count" | "last_update_type" | "update_count" | "needs_recompute" | "incidents_data" | "created_at" | "updated_at", ExtArgs["result"]["district_clusters"]>
  export type district_clustersInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type district_clustersIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }
  export type district_clustersIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    district?: boolean | districtsDefaultArgs<ExtArgs>
  }

  export type $district_clustersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "district_clusters"
    objects: {
      district: Prisma.$districtsPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      year: number
      month: number | null
      risk_level: $Enums.crime_rates
      total_crimes: number
      population_density: number
      unemployment_rate: number
      crime_score: number
      density_score: number
      unemployment_score: number
      cluster_score: number
      centroid_features: Prisma.JsonValue | null
      member_count: number
      last_update_type: string
      update_count: number
      needs_recompute: boolean
      incidents_data: Prisma.JsonValue | null
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["district_clusters"]>
    composites: {}
  }

  type district_clustersGetPayload<S extends boolean | null | undefined | district_clustersDefaultArgs> = $Result.GetResult<Prisma.$district_clustersPayload, S>

  type district_clustersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<district_clustersFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: District_clustersCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a District_clusters.
     * @param {district_clustersCreateArgs} args - Arguments to create a District_clusters.
     * @example
     * // Create one District_clusters
     * const District_clusters = await prisma.district_clusters.create({
     *   data: {
     *     // ... data to create a District_clusters
     *   }
     * })
     * 
     */
    create<T extends district_clustersCreateArgs>(args: SelectSubset<T, district_clustersCreateArgs<ExtArgs>>): Prisma__district_clustersClient<$Result.GetResult<Prisma.$district_clustersPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a District_clusters.
     * @param {district_clustersDeleteArgs} args - Arguments to delete one District_clusters.
     * @example
     * // Delete one District_clusters
     * const District_clusters = await prisma.district_clusters.delete({
     *   where: {
     *     // ... filter to delete one District_clusters
     *   }
     * })
     * 
     */
    delete<T extends district_clustersDeleteArgs>(args: SelectSubset<T, district_clustersDeleteArgs<ExtArgs>>): Prisma__district_clustersClient<$Result.GetResult<Prisma.$district_clustersPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the district_clusters model
   */
  interface district_clustersFieldRefs {
    readonly id: FieldRef<"district_clusters", 'String'>
    readonly district_id: FieldRef<"district_clusters", 'String'>
    readonly year: FieldRef<"district_clusters", 'Int'>
    readonly month: FieldRef<"district_clusters", 'Int'>
    readonly risk_level: FieldRef<"district_clusters", 'crime_rates'>
    readonly total_crimes: FieldRef<"district_clusters", 'Int'>
    readonly population_density: FieldRef<"district_clusters", 'Float'>
    readonly unemployment_rate: FieldRef<"district_clusters", 'Float'>
    readonly crime_score: FieldRef<"district_clusters", 'Float'>
    readonly density_score: FieldRef<"district_clusters", 'Float'>
    readonly unemployment_score: FieldRef<"district_clusters", 'Float'>
    readonly cluster_score: FieldRef<"district_clusters", 'Float'>
    readonly centroid_features: FieldRef<"district_clusters", 'Json'>
    readonly member_count: FieldRef<"district_clusters", 'Int'>
    readonly last_update_type: FieldRef<"district_clusters", 'String'>
    readonly update_count: FieldRef<"district_clusters", 'Int'>
    readonly needs_recompute: FieldRef<"district_clusters", 'Boolean'>
    readonly incidents_data: FieldRef<"district_clusters", 'Json'>
    readonly created_at: FieldRef<"district_clusters", 'DateTime'>
    readonly updated_at: FieldRef<"district_clusters", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * district_clusters findUnique
   */
  export type district_clustersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * Filter, which district_clusters to fetch.
     */
    where: district_clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * district_clusters findUniqueOrThrow
   */
  export type district_clustersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * Filter, which district_clusters to fetch.
     */
    where: district_clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * district_clusters findMany
   */
  export type district_clustersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * Filter, which district_clusters to fetch.
     */
    where?: district_clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of district_clusters to fetch.
     */
    orderBy?: district_clustersOrderByWithRelationInput | district_clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing district_clusters.
     */
    cursor?: district_clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` district_clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` district_clusters.
     */
    skip?: number
    distinct?: District_clustersScalarFieldEnum | District_clustersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * district_clusters create
   */
  export type district_clustersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * The data needed to create a district_clusters.
     */
    data: XOR<district_clustersCreateInput, district_clustersUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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

  /**
   * district_clusters update
   */
  export type district_clustersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * The data needed to update a district_clusters.
     */
    data: XOR<district_clustersUpdateInput, district_clustersUncheckedUpdateInput>
    /**
     * Choose, which district_clusters to update.
     */
    where: district_clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * district_clusters updateMany
   */
  export type district_clustersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update district_clusters.
     */
    data: XOR<district_clustersUpdateManyMutationInput, district_clustersUncheckedUpdateManyInput>
    /**
     * Filter which district_clusters to update
     */
    where?: district_clustersWhereInput
    /**
     * Limit how many district_clusters to update.
     */
    limit?: number
  }

  /**
   * district_clusters updateManyAndReturn
   */
  export type district_clustersUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * The data used to update district_clusters.
     */
    data: XOR<district_clustersUpdateManyMutationInput, district_clustersUncheckedUpdateManyInput>
    /**
     * Filter which district_clusters to update
     */
    where?: district_clustersWhereInput
    /**
     * Limit how many district_clusters to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * district_clusters upsert
   */
  export type district_clustersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * The filter to search for the district_clusters to update in case it exists.
     */
    where: district_clustersWhereUniqueInput
    /**
     * In case the district_clusters found by the `where` argument doesn't exist, create a new district_clusters with this data.
     */
    create: XOR<district_clustersCreateInput, district_clustersUncheckedCreateInput>
    /**
     * In case the district_clusters was found with the provided `where` argument, update it with this data.
     */
    update: XOR<district_clustersUpdateInput, district_clustersUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * district_clusters delete
   */
  export type district_clustersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the district_clusters
     */
    select?: district_clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the district_clusters
     */
    omit?: district_clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: district_clustersInclude<ExtArgs> | null
    /**
     * Filter which district_clusters to delete.
     */
    where: district_clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

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

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


  /**
   * Model cluster_updates
   */

  export type AggregateCluster_updates = {
    _count: Cluster_updatesCountAggregateOutputType | null
    _min: Cluster_updatesMinAggregateOutputType | null
    _max: Cluster_updatesMaxAggregateOutputType | null
  }

  export type Cluster_updatesMinAggregateOutputType = {
    id: string | null
    district_id: string | null
    update_type: string | null
    processed: boolean | null
    timestamp: Date | null
  }

  export type Cluster_updatesMaxAggregateOutputType = {
    id: string | null
    district_id: string | null
    update_type: string | null
    processed: boolean | null
    timestamp: Date | null
  }

  export type Cluster_updatesCountAggregateOutputType = {
    id: number
    district_id: number
    update_type: number
    old_value: number
    new_value: number
    processed: number
    timestamp: number
    _all: number
  }


  export type Cluster_updatesMinAggregateInputType = {
    id?: true
    district_id?: true
    update_type?: true
    processed?: true
    timestamp?: true
  }

  export type Cluster_updatesMaxAggregateInputType = {
    id?: true
    district_id?: true
    update_type?: true
    processed?: true
    timestamp?: true
  }

  export type Cluster_updatesCountAggregateInputType = {
    id?: true
    district_id?: true
    update_type?: true
    old_value?: true
    new_value?: true
    processed?: true
    timestamp?: true
    _all?: true
  }

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

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




  export type cluster_updatesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: cluster_updatesWhereInput
    orderBy?: cluster_updatesOrderByWithAggregationInput | cluster_updatesOrderByWithAggregationInput[]
    by: Cluster_updatesScalarFieldEnum[] | Cluster_updatesScalarFieldEnum
    having?: cluster_updatesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Cluster_updatesCountAggregateInputType | true
    _min?: Cluster_updatesMinAggregateInputType
    _max?: Cluster_updatesMaxAggregateInputType
  }

  export type Cluster_updatesGroupByOutputType = {
    id: string
    district_id: string
    update_type: string
    old_value: JsonValue | null
    new_value: JsonValue | null
    processed: boolean
    timestamp: Date
    _count: Cluster_updatesCountAggregateOutputType | null
    _min: Cluster_updatesMinAggregateOutputType | null
    _max: Cluster_updatesMaxAggregateOutputType | null
  }

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


  export type cluster_updatesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    update_type?: boolean
    old_value?: boolean
    new_value?: boolean
    processed?: boolean
    timestamp?: boolean
  }, ExtArgs["result"]["cluster_updates"]>

  export type cluster_updatesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    update_type?: boolean
    old_value?: boolean
    new_value?: boolean
    processed?: boolean
    timestamp?: boolean
  }, ExtArgs["result"]["cluster_updates"]>

  export type cluster_updatesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    district_id?: boolean
    update_type?: boolean
    old_value?: boolean
    new_value?: boolean
    processed?: boolean
    timestamp?: boolean
  }, ExtArgs["result"]["cluster_updates"]>

  export type cluster_updatesSelectScalar = {
    id?: boolean
    district_id?: boolean
    update_type?: boolean
    old_value?: boolean
    new_value?: boolean
    processed?: boolean
    timestamp?: boolean
  }

  export type cluster_updatesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "district_id" | "update_type" | "old_value" | "new_value" | "processed" | "timestamp", ExtArgs["result"]["cluster_updates"]>

  export type $cluster_updatesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "cluster_updates"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      district_id: string
      update_type: string
      old_value: Prisma.JsonValue | null
      new_value: Prisma.JsonValue | null
      processed: boolean
      timestamp: Date
    }, ExtArgs["result"]["cluster_updates"]>
    composites: {}
  }

  type cluster_updatesGetPayload<S extends boolean | null | undefined | cluster_updatesDefaultArgs> = $Result.GetResult<Prisma.$cluster_updatesPayload, S>

  type cluster_updatesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<cluster_updatesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Cluster_updatesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Cluster_updates.
     * @param {cluster_updatesCreateArgs} args - Arguments to create a Cluster_updates.
     * @example
     * // Create one Cluster_updates
     * const Cluster_updates = await prisma.cluster_updates.create({
     *   data: {
     *     // ... data to create a Cluster_updates
     *   }
     * })
     * 
     */
    create<T extends cluster_updatesCreateArgs>(args: SelectSubset<T, cluster_updatesCreateArgs<ExtArgs>>): Prisma__cluster_updatesClient<$Result.GetResult<Prisma.$cluster_updatesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a Cluster_updates.
     * @param {cluster_updatesDeleteArgs} args - Arguments to delete one Cluster_updates.
     * @example
     * // Delete one Cluster_updates
     * const Cluster_updates = await prisma.cluster_updates.delete({
     *   where: {
     *     // ... filter to delete one Cluster_updates
     *   }
     * })
     * 
     */
    delete<T extends cluster_updatesDeleteArgs>(args: SelectSubset<T, cluster_updatesDeleteArgs<ExtArgs>>): Prisma__cluster_updatesClient<$Result.GetResult<Prisma.$cluster_updatesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for cluster_updates.
   * 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__cluster_updatesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the cluster_updates model
   */
  interface cluster_updatesFieldRefs {
    readonly id: FieldRef<"cluster_updates", 'String'>
    readonly district_id: FieldRef<"cluster_updates", 'String'>
    readonly update_type: FieldRef<"cluster_updates", 'String'>
    readonly old_value: FieldRef<"cluster_updates", 'Json'>
    readonly new_value: FieldRef<"cluster_updates", 'Json'>
    readonly processed: FieldRef<"cluster_updates", 'Boolean'>
    readonly timestamp: FieldRef<"cluster_updates", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * cluster_updates findUnique
   */
  export type cluster_updatesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter, which cluster_updates to fetch.
     */
    where: cluster_updatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates findUniqueOrThrow
   */
  export type cluster_updatesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter, which cluster_updates to fetch.
     */
    where: cluster_updatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates findFirst
   */
  export type cluster_updatesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter, which cluster_updates to fetch.
     */
    where?: cluster_updatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of cluster_updates to fetch.
     */
    orderBy?: cluster_updatesOrderByWithRelationInput | cluster_updatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for cluster_updates.
     */
    cursor?: cluster_updatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` cluster_updates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` cluster_updates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of cluster_updates.
     */
    distinct?: Cluster_updatesScalarFieldEnum | Cluster_updatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates findFirstOrThrow
   */
  export type cluster_updatesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter, which cluster_updates to fetch.
     */
    where?: cluster_updatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of cluster_updates to fetch.
     */
    orderBy?: cluster_updatesOrderByWithRelationInput | cluster_updatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for cluster_updates.
     */
    cursor?: cluster_updatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` cluster_updates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` cluster_updates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of cluster_updates.
     */
    distinct?: Cluster_updatesScalarFieldEnum | Cluster_updatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates findMany
   */
  export type cluster_updatesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter, which cluster_updates to fetch.
     */
    where?: cluster_updatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of cluster_updates to fetch.
     */
    orderBy?: cluster_updatesOrderByWithRelationInput | cluster_updatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing cluster_updates.
     */
    cursor?: cluster_updatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` cluster_updates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` cluster_updates.
     */
    skip?: number
    distinct?: Cluster_updatesScalarFieldEnum | Cluster_updatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates create
   */
  export type cluster_updatesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * The data needed to create a cluster_updates.
     */
    data: XOR<cluster_updatesCreateInput, cluster_updatesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates createMany
   */
  export type cluster_updatesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many cluster_updates.
     */
    data: cluster_updatesCreateManyInput | cluster_updatesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * cluster_updates createManyAndReturn
   */
  export type cluster_updatesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * The data used to create many cluster_updates.
     */
    data: cluster_updatesCreateManyInput | cluster_updatesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * cluster_updates update
   */
  export type cluster_updatesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * The data needed to update a cluster_updates.
     */
    data: XOR<cluster_updatesUpdateInput, cluster_updatesUncheckedUpdateInput>
    /**
     * Choose, which cluster_updates to update.
     */
    where: cluster_updatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates updateMany
   */
  export type cluster_updatesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update cluster_updates.
     */
    data: XOR<cluster_updatesUpdateManyMutationInput, cluster_updatesUncheckedUpdateManyInput>
    /**
     * Filter which cluster_updates to update
     */
    where?: cluster_updatesWhereInput
    /**
     * Limit how many cluster_updates to update.
     */
    limit?: number
  }

  /**
   * cluster_updates updateManyAndReturn
   */
  export type cluster_updatesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * The data used to update cluster_updates.
     */
    data: XOR<cluster_updatesUpdateManyMutationInput, cluster_updatesUncheckedUpdateManyInput>
    /**
     * Filter which cluster_updates to update
     */
    where?: cluster_updatesWhereInput
    /**
     * Limit how many cluster_updates to update.
     */
    limit?: number
  }

  /**
   * cluster_updates upsert
   */
  export type cluster_updatesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * The filter to search for the cluster_updates to update in case it exists.
     */
    where: cluster_updatesWhereUniqueInput
    /**
     * In case the cluster_updates found by the `where` argument doesn't exist, create a new cluster_updates with this data.
     */
    create: XOR<cluster_updatesCreateInput, cluster_updatesUncheckedCreateInput>
    /**
     * In case the cluster_updates was found with the provided `where` argument, update it with this data.
     */
    update: XOR<cluster_updatesUpdateInput, cluster_updatesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates delete
   */
  export type cluster_updatesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
    /**
     * Filter which cluster_updates to delete.
     */
    where: cluster_updatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * cluster_updates deleteMany
   */
  export type cluster_updatesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which cluster_updates to delete
     */
    where?: cluster_updatesWhereInput
    /**
     * Limit how many cluster_updates to delete.
     */
    limit?: number
  }

  /**
   * cluster_updates without action
   */
  export type cluster_updatesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the cluster_updates
     */
    select?: cluster_updatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the cluster_updates
     */
    omit?: cluster_updatesOmit<ExtArgs> | null
  }


  /**
   * Model task
   */

  export type AggregateTask = {
    _count: TaskCountAggregateOutputType | null
    _avg: TaskAvgAggregateOutputType | null
    _sum: TaskSumAggregateOutputType | null
    _min: TaskMinAggregateOutputType | null
    _max: TaskMaxAggregateOutputType | null
  }

  export type TaskAvgAggregateOutputType = {
    estimated_hours: number | null
  }

  export type TaskSumAggregateOutputType = {
    estimated_hours: number | null
  }

  export type TaskMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    code: string | null
    title: string | null
    status: $Enums.task_status | null
    label: $Enums.task_label | null
    priority: $Enums.task_priority | null
    estimated_hours: number | null
    archived: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TaskMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    code: string | null
    title: string | null
    status: $Enums.task_status | null
    label: $Enums.task_label | null
    priority: $Enums.task_priority | null
    estimated_hours: number | null
    archived: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TaskCountAggregateOutputType = {
    id: number
    user_id: number
    code: number
    title: number
    status: number
    label: number
    priority: number
    estimated_hours: number
    archived: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type TaskAvgAggregateInputType = {
    estimated_hours?: true
  }

  export type TaskSumAggregateInputType = {
    estimated_hours?: true
  }

  export type TaskMinAggregateInputType = {
    id?: true
    user_id?: true
    code?: true
    title?: true
    status?: true
    label?: true
    priority?: true
    estimated_hours?: true
    archived?: true
    created_at?: true
    updated_at?: true
  }

  export type TaskMaxAggregateInputType = {
    id?: true
    user_id?: true
    code?: true
    title?: true
    status?: true
    label?: true
    priority?: true
    estimated_hours?: true
    archived?: true
    created_at?: true
    updated_at?: true
  }

  export type TaskCountAggregateInputType = {
    id?: true
    user_id?: true
    code?: true
    title?: true
    status?: true
    label?: true
    priority?: true
    estimated_hours?: true
    archived?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type TaskAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which task to aggregate.
     */
    where?: taskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tasks to fetch.
     */
    orderBy?: taskOrderByWithRelationInput | taskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: taskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tasks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tasks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned tasks
    **/
    _count?: true | TaskCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TaskAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TaskSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TaskMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TaskMaxAggregateInputType
  }

  export type GetTaskAggregateType<T extends TaskAggregateArgs> = {
        [P in keyof T & keyof AggregateTask]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateTask[P]>
      : GetScalarType<T[P], AggregateTask[P]>
  }




  export type taskGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: taskWhereInput
    orderBy?: taskOrderByWithAggregationInput | taskOrderByWithAggregationInput[]
    by: TaskScalarFieldEnum[] | TaskScalarFieldEnum
    having?: taskScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TaskCountAggregateInputType | true
    _avg?: TaskAvgAggregateInputType
    _sum?: TaskSumAggregateInputType
    _min?: TaskMinAggregateInputType
    _max?: TaskMaxAggregateInputType
  }

  export type TaskGroupByOutputType = {
    id: string
    user_id: string
    code: string
    title: string | null
    status: $Enums.task_status
    label: $Enums.task_label
    priority: $Enums.task_priority
    estimated_hours: number
    archived: boolean
    created_at: Date
    updated_at: Date
    _count: TaskCountAggregateOutputType | null
    _avg: TaskAvgAggregateOutputType | null
    _sum: TaskSumAggregateOutputType | null
    _min: TaskMinAggregateOutputType | null
    _max: TaskMaxAggregateOutputType | null
  }

  type GetTaskGroupByPayload<T extends taskGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TaskGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TaskGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TaskGroupByOutputType[P]>
            : GetScalarType<T[P], TaskGroupByOutputType[P]>
        }
      >
    >


  export type taskSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    code?: boolean
    title?: boolean
    status?: boolean
    label?: boolean
    priority?: boolean
    estimated_hours?: boolean
    archived?: boolean
    created_at?: boolean
    updated_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["task"]>

  export type taskSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    code?: boolean
    title?: boolean
    status?: boolean
    label?: boolean
    priority?: boolean
    estimated_hours?: boolean
    archived?: boolean
    created_at?: boolean
    updated_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["task"]>

  export type taskSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    code?: boolean
    title?: boolean
    status?: boolean
    label?: boolean
    priority?: boolean
    estimated_hours?: boolean
    archived?: boolean
    created_at?: boolean
    updated_at?: boolean
    user?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["task"]>

  export type taskSelectScalar = {
    id?: boolean
    user_id?: boolean
    code?: boolean
    title?: boolean
    status?: boolean
    label?: boolean
    priority?: boolean
    estimated_hours?: boolean
    archived?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type taskOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "user_id" | "code" | "title" | "status" | "label" | "priority" | "estimated_hours" | "archived" | "created_at" | "updated_at", ExtArgs["result"]["task"]>
  export type taskInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type taskIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type taskIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $taskPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "task"
    objects: {
      user: Prisma.$usersPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      code: string
      title: string | null
      status: $Enums.task_status
      label: $Enums.task_label
      priority: $Enums.task_priority
      estimated_hours: number
      archived: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["task"]>
    composites: {}
  }

  type taskGetPayload<S extends boolean | null | undefined | taskDefaultArgs> = $Result.GetResult<Prisma.$taskPayload, S>

  type taskCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<taskFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: TaskCountAggregateInputType | true
    }

  export interface taskDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['task'], meta: { name: 'task' } }
    /**
     * Find zero or one Task that matches the filter.
     * @param {taskFindUniqueArgs} args - Arguments to find a Task
     * @example
     * // Get one Task
     * const task = await prisma.task.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends taskFindUniqueArgs>(args: SelectSubset<T, taskFindUniqueArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Task that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {taskFindUniqueOrThrowArgs} args - Arguments to find a Task
     * @example
     * // Get one Task
     * const task = await prisma.task.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends taskFindUniqueOrThrowArgs>(args: SelectSubset<T, taskFindUniqueOrThrowArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Task 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 {taskFindFirstArgs} args - Arguments to find a Task
     * @example
     * // Get one Task
     * const task = await prisma.task.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends taskFindFirstArgs>(args?: SelectSubset<T, taskFindFirstArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Task 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 {taskFindFirstOrThrowArgs} args - Arguments to find a Task
     * @example
     * // Get one Task
     * const task = await prisma.task.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends taskFindFirstOrThrowArgs>(args?: SelectSubset<T, taskFindFirstOrThrowArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Tasks 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 {taskFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Tasks
     * const tasks = await prisma.task.findMany()
     * 
     * // Get first 10 Tasks
     * const tasks = await prisma.task.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const taskWithIdOnly = await prisma.task.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends taskFindManyArgs>(args?: SelectSubset<T, taskFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Task.
     * @param {taskCreateArgs} args - Arguments to create a Task.
     * @example
     * // Create one Task
     * const Task = await prisma.task.create({
     *   data: {
     *     // ... data to create a Task
     *   }
     * })
     * 
     */
    create<T extends taskCreateArgs>(args: SelectSubset<T, taskCreateArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Tasks.
     * @param {taskCreateManyArgs} args - Arguments to create many Tasks.
     * @example
     * // Create many Tasks
     * const task = await prisma.task.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends taskCreateManyArgs>(args?: SelectSubset<T, taskCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Tasks and returns the data saved in the database.
     * @param {taskCreateManyAndReturnArgs} args - Arguments to create many Tasks.
     * @example
     * // Create many Tasks
     * const task = await prisma.task.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Tasks and only return the `id`
     * const taskWithIdOnly = await prisma.task.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 taskCreateManyAndReturnArgs>(args?: SelectSubset<T, taskCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Task.
     * @param {taskDeleteArgs} args - Arguments to delete one Task.
     * @example
     * // Delete one Task
     * const Task = await prisma.task.delete({
     *   where: {
     *     // ... filter to delete one Task
     *   }
     * })
     * 
     */
    delete<T extends taskDeleteArgs>(args: SelectSubset<T, taskDeleteArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Task.
     * @param {taskUpdateArgs} args - Arguments to update one Task.
     * @example
     * // Update one Task
     * const task = await prisma.task.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends taskUpdateArgs>(args: SelectSubset<T, taskUpdateArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Tasks.
     * @param {taskDeleteManyArgs} args - Arguments to filter Tasks to delete.
     * @example
     * // Delete a few Tasks
     * const { count } = await prisma.task.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends taskDeleteManyArgs>(args?: SelectSubset<T, taskDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Tasks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {taskUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Tasks
     * const task = await prisma.task.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends taskUpdateManyArgs>(args: SelectSubset<T, taskUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Tasks and returns the data updated in the database.
     * @param {taskUpdateManyAndReturnArgs} args - Arguments to update many Tasks.
     * @example
     * // Update many Tasks
     * const task = await prisma.task.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Tasks and only return the `id`
     * const taskWithIdOnly = await prisma.task.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends taskUpdateManyAndReturnArgs>(args: SelectSubset<T, taskUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Task.
     * @param {taskUpsertArgs} args - Arguments to update or create a Task.
     * @example
     * // Update or create a Task
     * const task = await prisma.task.upsert({
     *   create: {
     *     // ... data to create a Task
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Task we want to update
     *   }
     * })
     */
    upsert<T extends taskUpsertArgs>(args: SelectSubset<T, taskUpsertArgs<ExtArgs>>): Prisma__taskClient<$Result.GetResult<Prisma.$taskPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Tasks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {taskCountArgs} args - Arguments to filter Tasks to count.
     * @example
     * // Count the number of Tasks
     * const count = await prisma.task.count({
     *   where: {
     *     // ... the filter for the Tasks we want to count
     *   }
     * })
    **/
    count<T extends taskCountArgs>(
      args?: Subset<T, taskCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TaskCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Task.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TaskAggregateArgs} 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 TaskAggregateArgs>(args: Subset<T, TaskAggregateArgs>): Prisma.PrismaPromise<GetTaskAggregateType<T>>

    /**
     * Group by Task.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {taskGroupByArgs} 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 taskGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: taskGroupByArgs['orderBy'] }
        : { orderBy?: taskGroupByArgs['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, taskGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTaskGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the task model
   */
  readonly fields: taskFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for task.
   * 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__taskClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends usersDefaultArgs<ExtArgs> = {}>(args?: Subset<T, usersDefaultArgs<ExtArgs>>): Prisma__usersClient<$Result.GetResult<Prisma.$usersPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the task model
   */
  interface taskFieldRefs {
    readonly id: FieldRef<"task", 'String'>
    readonly user_id: FieldRef<"task", 'String'>
    readonly code: FieldRef<"task", 'String'>
    readonly title: FieldRef<"task", 'String'>
    readonly status: FieldRef<"task", 'task_status'>
    readonly label: FieldRef<"task", 'task_label'>
    readonly priority: FieldRef<"task", 'task_priority'>
    readonly estimated_hours: FieldRef<"task", 'Float'>
    readonly archived: FieldRef<"task", 'Boolean'>
    readonly created_at: FieldRef<"task", 'DateTime'>
    readonly updated_at: FieldRef<"task", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * task findUnique
   */
  export type taskFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter, which task to fetch.
     */
    where: taskWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task findUniqueOrThrow
   */
  export type taskFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter, which task to fetch.
     */
    where: taskWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task findFirst
   */
  export type taskFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter, which task to fetch.
     */
    where?: taskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tasks to fetch.
     */
    orderBy?: taskOrderByWithRelationInput | taskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for tasks.
     */
    cursor?: taskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tasks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tasks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of tasks.
     */
    distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task findFirstOrThrow
   */
  export type taskFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter, which task to fetch.
     */
    where?: taskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tasks to fetch.
     */
    orderBy?: taskOrderByWithRelationInput | taskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for tasks.
     */
    cursor?: taskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tasks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tasks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of tasks.
     */
    distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task findMany
   */
  export type taskFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter, which tasks to fetch.
     */
    where?: taskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tasks to fetch.
     */
    orderBy?: taskOrderByWithRelationInput | taskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing tasks.
     */
    cursor?: taskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tasks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tasks.
     */
    skip?: number
    distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task create
   */
  export type taskCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * The data needed to create a task.
     */
    data: XOR<taskCreateInput, taskUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task createMany
   */
  export type taskCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many tasks.
     */
    data: taskCreateManyInput | taskCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * task createManyAndReturn
   */
  export type taskCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * The data used to create many tasks.
     */
    data: taskCreateManyInput | taskCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * task update
   */
  export type taskUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * The data needed to update a task.
     */
    data: XOR<taskUpdateInput, taskUncheckedUpdateInput>
    /**
     * Choose, which task to update.
     */
    where: taskWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task updateMany
   */
  export type taskUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update tasks.
     */
    data: XOR<taskUpdateManyMutationInput, taskUncheckedUpdateManyInput>
    /**
     * Filter which tasks to update
     */
    where?: taskWhereInput
    /**
     * Limit how many tasks to update.
     */
    limit?: number
  }

  /**
   * task updateManyAndReturn
   */
  export type taskUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * The data used to update tasks.
     */
    data: XOR<taskUpdateManyMutationInput, taskUncheckedUpdateManyInput>
    /**
     * Filter which tasks to update
     */
    where?: taskWhereInput
    /**
     * Limit how many tasks to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * task upsert
   */
  export type taskUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * The filter to search for the task to update in case it exists.
     */
    where: taskWhereUniqueInput
    /**
     * In case the task found by the `where` argument doesn't exist, create a new task with this data.
     */
    create: XOR<taskCreateInput, taskUncheckedCreateInput>
    /**
     * In case the task was found with the provided `where` argument, update it with this data.
     */
    update: XOR<taskUpdateInput, taskUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task delete
   */
  export type taskDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
    /**
     * Filter which task to delete.
     */
    where: taskWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * task deleteMany
   */
  export type taskDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which tasks to delete
     */
    where?: taskWhereInput
    /**
     * Limit how many tasks to delete.
     */
    limit?: number
  }

  /**
   * task without action
   */
  export type taskDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the task
     */
    select?: taskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the task
     */
    omit?: taskOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: taskInclude<ExtArgs> | null
  }


  /**
   * Model projects
   */

  export type AggregateProjects = {
    _count: ProjectsCountAggregateOutputType | null
    _min: ProjectsMinAggregateOutputType | null
    _max: ProjectsMaxAggregateOutputType | null
  }

  export type ProjectsMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    user_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProjectsMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    user_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProjectsCountAggregateOutputType = {
    id: number
    name: number
    description: number
    user_id: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ProjectsMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    user_id?: true
    created_at?: true
    updated_at?: true
  }

  export type ProjectsMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    user_id?: true
    created_at?: true
    updated_at?: true
  }

  export type ProjectsCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    user_id?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ProjectsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which projects to aggregate.
     */
    where?: projectsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of projects to fetch.
     */
    orderBy?: projectsOrderByWithRelationInput | projectsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: projectsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` projects from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` projects.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned projects
    **/
    _count?: true | ProjectsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProjectsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProjectsMaxAggregateInputType
  }

  export type GetProjectsAggregateType<T extends ProjectsAggregateArgs> = {
        [P in keyof T & keyof AggregateProjects]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateProjects[P]>
      : GetScalarType<T[P], AggregateProjects[P]>
  }




  export type projectsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: projectsWhereInput
    orderBy?: projectsOrderByWithAggregationInput | projectsOrderByWithAggregationInput[]
    by: ProjectsScalarFieldEnum[] | ProjectsScalarFieldEnum
    having?: projectsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProjectsCountAggregateInputType | true
    _min?: ProjectsMinAggregateInputType
    _max?: ProjectsMaxAggregateInputType
  }

  export type ProjectsGroupByOutputType = {
    id: string
    name: string
    description: string | null
    user_id: string
    created_at: Date
    updated_at: Date
    _count: ProjectsCountAggregateOutputType | null
    _min: ProjectsMinAggregateOutputType | null
    _max: ProjectsMaxAggregateOutputType | null
  }

  type GetProjectsGroupByPayload<T extends projectsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ProjectsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ProjectsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ProjectsGroupByOutputType[P]>
            : GetScalarType<T[P], ProjectsGroupByOutputType[P]>
        }
      >
    >


  export type projectsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    user_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
    datasets?: boolean | projects$datasetsArgs<ExtArgs>
    analyses?: boolean | projects$analysesArgs<ExtArgs>
    _count?: boolean | ProjectsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["projects"]>

  export type projectsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    user_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["projects"]>

  export type projectsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    user_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    users?: boolean | usersDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["projects"]>

  export type projectsSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    user_id?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type projectsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "user_id" | "created_at" | "updated_at", ExtArgs["result"]["projects"]>
  export type projectsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
    datasets?: boolean | projects$datasetsArgs<ExtArgs>
    analyses?: boolean | projects$analysesArgs<ExtArgs>
    _count?: boolean | ProjectsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type projectsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }
  export type projectsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | usersDefaultArgs<ExtArgs>
  }

  export type $projectsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "projects"
    objects: {
      users: Prisma.$usersPayload<ExtArgs>
      datasets: Prisma.$datasetsPayload<ExtArgs>[]
      analyses: Prisma.$analysesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      user_id: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["projects"]>
    composites: {}
  }

  type projectsGetPayload<S extends boolean | null | undefined | projectsDefaultArgs> = $Result.GetResult<Prisma.$projectsPayload, S>

  type projectsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<projectsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: ProjectsCountAggregateInputType | true
    }

  export interface projectsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['projects'], meta: { name: 'projects' } }
    /**
     * Find zero or one Projects that matches the filter.
     * @param {projectsFindUniqueArgs} args - Arguments to find a Projects
     * @example
     * // Get one Projects
     * const projects = await prisma.projects.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends projectsFindUniqueArgs>(args: SelectSubset<T, projectsFindUniqueArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Projects that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {projectsFindUniqueOrThrowArgs} args - Arguments to find a Projects
     * @example
     * // Get one Projects
     * const projects = await prisma.projects.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends projectsFindUniqueOrThrowArgs>(args: SelectSubset<T, projectsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Projects 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 {projectsFindFirstArgs} args - Arguments to find a Projects
     * @example
     * // Get one Projects
     * const projects = await prisma.projects.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends projectsFindFirstArgs>(args?: SelectSubset<T, projectsFindFirstArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Projects 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 {projectsFindFirstOrThrowArgs} args - Arguments to find a Projects
     * @example
     * // Get one Projects
     * const projects = await prisma.projects.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends projectsFindFirstOrThrowArgs>(args?: SelectSubset<T, projectsFindFirstOrThrowArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Projects 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 {projectsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Projects
     * const projects = await prisma.projects.findMany()
     * 
     * // Get first 10 Projects
     * const projects = await prisma.projects.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const projectsWithIdOnly = await prisma.projects.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends projectsFindManyArgs>(args?: SelectSubset<T, projectsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Projects.
     * @param {projectsCreateArgs} args - Arguments to create a Projects.
     * @example
     * // Create one Projects
     * const Projects = await prisma.projects.create({
     *   data: {
     *     // ... data to create a Projects
     *   }
     * })
     * 
     */
    create<T extends projectsCreateArgs>(args: SelectSubset<T, projectsCreateArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Projects.
     * @param {projectsCreateManyArgs} args - Arguments to create many Projects.
     * @example
     * // Create many Projects
     * const projects = await prisma.projects.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends projectsCreateManyArgs>(args?: SelectSubset<T, projectsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Projects and returns the data saved in the database.
     * @param {projectsCreateManyAndReturnArgs} args - Arguments to create many Projects.
     * @example
     * // Create many Projects
     * const projects = await prisma.projects.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Projects and only return the `id`
     * const projectsWithIdOnly = await prisma.projects.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 projectsCreateManyAndReturnArgs>(args?: SelectSubset<T, projectsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Projects.
     * @param {projectsDeleteArgs} args - Arguments to delete one Projects.
     * @example
     * // Delete one Projects
     * const Projects = await prisma.projects.delete({
     *   where: {
     *     // ... filter to delete one Projects
     *   }
     * })
     * 
     */
    delete<T extends projectsDeleteArgs>(args: SelectSubset<T, projectsDeleteArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Projects.
     * @param {projectsUpdateArgs} args - Arguments to update one Projects.
     * @example
     * // Update one Projects
     * const projects = await prisma.projects.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends projectsUpdateArgs>(args: SelectSubset<T, projectsUpdateArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Projects.
     * @param {projectsDeleteManyArgs} args - Arguments to filter Projects to delete.
     * @example
     * // Delete a few Projects
     * const { count } = await prisma.projects.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends projectsDeleteManyArgs>(args?: SelectSubset<T, projectsDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Projects.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {projectsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Projects
     * const projects = await prisma.projects.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends projectsUpdateManyArgs>(args: SelectSubset<T, projectsUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Projects and returns the data updated in the database.
     * @param {projectsUpdateManyAndReturnArgs} args - Arguments to update many Projects.
     * @example
     * // Update many Projects
     * const projects = await prisma.projects.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Projects and only return the `id`
     * const projectsWithIdOnly = await prisma.projects.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends projectsUpdateManyAndReturnArgs>(args: SelectSubset<T, projectsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Projects.
     * @param {projectsUpsertArgs} args - Arguments to update or create a Projects.
     * @example
     * // Update or create a Projects
     * const projects = await prisma.projects.upsert({
     *   create: {
     *     // ... data to create a Projects
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Projects we want to update
     *   }
     * })
     */
    upsert<T extends projectsUpsertArgs>(args: SelectSubset<T, projectsUpsertArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Projects.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {projectsCountArgs} args - Arguments to filter Projects to count.
     * @example
     * // Count the number of Projects
     * const count = await prisma.projects.count({
     *   where: {
     *     // ... the filter for the Projects we want to count
     *   }
     * })
    **/
    count<T extends projectsCountArgs>(
      args?: Subset<T, projectsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ProjectsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Projects.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProjectsAggregateArgs} 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 ProjectsAggregateArgs>(args: Subset<T, ProjectsAggregateArgs>): Prisma.PrismaPromise<GetProjectsAggregateType<T>>

    /**
     * Group by Projects.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {projectsGroupByArgs} 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 projectsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: projectsGroupByArgs['orderBy'] }
        : { orderBy?: projectsGroupByArgs['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, projectsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProjectsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the projects model
   */
  readonly fields: projectsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for projects.
   * 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__projectsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    users<T extends usersDefaultArgs<ExtArgs> = {}>(args?: Subset<T, usersDefaultArgs<ExtArgs>>): Prisma__usersClient<$Result.GetResult<Prisma.$usersPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    datasets<T extends projects$datasetsArgs<ExtArgs> = {}>(args?: Subset<T, projects$datasetsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    analyses<T extends projects$analysesArgs<ExtArgs> = {}>(args?: Subset<T, projects$analysesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the projects model
   */
  interface projectsFieldRefs {
    readonly id: FieldRef<"projects", 'String'>
    readonly name: FieldRef<"projects", 'String'>
    readonly description: FieldRef<"projects", 'String'>
    readonly user_id: FieldRef<"projects", 'String'>
    readonly created_at: FieldRef<"projects", 'DateTime'>
    readonly updated_at: FieldRef<"projects", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * projects findUnique
   */
  export type projectsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter, which projects to fetch.
     */
    where: projectsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects findUniqueOrThrow
   */
  export type projectsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter, which projects to fetch.
     */
    where: projectsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects findFirst
   */
  export type projectsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter, which projects to fetch.
     */
    where?: projectsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of projects to fetch.
     */
    orderBy?: projectsOrderByWithRelationInput | projectsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for projects.
     */
    cursor?: projectsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` projects from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` projects.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of projects.
     */
    distinct?: ProjectsScalarFieldEnum | ProjectsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects findFirstOrThrow
   */
  export type projectsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter, which projects to fetch.
     */
    where?: projectsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of projects to fetch.
     */
    orderBy?: projectsOrderByWithRelationInput | projectsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for projects.
     */
    cursor?: projectsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` projects from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` projects.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of projects.
     */
    distinct?: ProjectsScalarFieldEnum | ProjectsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects findMany
   */
  export type projectsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter, which projects to fetch.
     */
    where?: projectsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of projects to fetch.
     */
    orderBy?: projectsOrderByWithRelationInput | projectsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing projects.
     */
    cursor?: projectsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` projects from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` projects.
     */
    skip?: number
    distinct?: ProjectsScalarFieldEnum | ProjectsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects create
   */
  export type projectsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * The data needed to create a projects.
     */
    data: XOR<projectsCreateInput, projectsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects createMany
   */
  export type projectsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many projects.
     */
    data: projectsCreateManyInput | projectsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * projects createManyAndReturn
   */
  export type projectsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * The data used to create many projects.
     */
    data: projectsCreateManyInput | projectsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * projects update
   */
  export type projectsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * The data needed to update a projects.
     */
    data: XOR<projectsUpdateInput, projectsUncheckedUpdateInput>
    /**
     * Choose, which projects to update.
     */
    where: projectsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects updateMany
   */
  export type projectsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update projects.
     */
    data: XOR<projectsUpdateManyMutationInput, projectsUncheckedUpdateManyInput>
    /**
     * Filter which projects to update
     */
    where?: projectsWhereInput
    /**
     * Limit how many projects to update.
     */
    limit?: number
  }

  /**
   * projects updateManyAndReturn
   */
  export type projectsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * The data used to update projects.
     */
    data: XOR<projectsUpdateManyMutationInput, projectsUncheckedUpdateManyInput>
    /**
     * Filter which projects to update
     */
    where?: projectsWhereInput
    /**
     * Limit how many projects to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * projects upsert
   */
  export type projectsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * The filter to search for the projects to update in case it exists.
     */
    where: projectsWhereUniqueInput
    /**
     * In case the projects found by the `where` argument doesn't exist, create a new projects with this data.
     */
    create: XOR<projectsCreateInput, projectsUncheckedCreateInput>
    /**
     * In case the projects was found with the provided `where` argument, update it with this data.
     */
    update: XOR<projectsUpdateInput, projectsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects delete
   */
  export type projectsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
    /**
     * Filter which projects to delete.
     */
    where: projectsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * projects deleteMany
   */
  export type projectsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which projects to delete
     */
    where?: projectsWhereInput
    /**
     * Limit how many projects to delete.
     */
    limit?: number
  }

  /**
   * projects.datasets
   */
  export type projects$datasetsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    where?: datasetsWhereInput
    orderBy?: datasetsOrderByWithRelationInput | datasetsOrderByWithRelationInput[]
    cursor?: datasetsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DatasetsScalarFieldEnum | DatasetsScalarFieldEnum[]
  }

  /**
   * projects.analyses
   */
  export type projects$analysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    where?: analysesWhereInput
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    cursor?: analysesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AnalysesScalarFieldEnum | AnalysesScalarFieldEnum[]
  }

  /**
   * projects without action
   */
  export type projectsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the projects
     */
    select?: projectsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the projects
     */
    omit?: projectsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: projectsInclude<ExtArgs> | null
  }


  /**
   * Model datasets
   */

  export type AggregateDatasets = {
    _count: DatasetsCountAggregateOutputType | null
    _avg: DatasetsAvgAggregateOutputType | null
    _sum: DatasetsSumAggregateOutputType | null
    _min: DatasetsMinAggregateOutputType | null
    _max: DatasetsMaxAggregateOutputType | null
  }

  export type DatasetsAvgAggregateOutputType = {
    file_size: number | null
    row_count: number | null
  }

  export type DatasetsSumAggregateOutputType = {
    file_size: number | null
    row_count: number | null
  }

  export type DatasetsMinAggregateOutputType = {
    id: string | null
    project_id: string | null
    filename: string | null
    original_name: string | null
    file_size: number | null
    row_count: number | null
    created_at: Date | null
  }

  export type DatasetsMaxAggregateOutputType = {
    id: string | null
    project_id: string | null
    filename: string | null
    original_name: string | null
    file_size: number | null
    row_count: number | null
    created_at: Date | null
  }

  export type DatasetsCountAggregateOutputType = {
    id: number
    project_id: number
    filename: number
    original_name: number
    file_size: number
    columns: number
    row_count: number
    metadata: number
    created_at: number
    _all: number
  }


  export type DatasetsAvgAggregateInputType = {
    file_size?: true
    row_count?: true
  }

  export type DatasetsSumAggregateInputType = {
    file_size?: true
    row_count?: true
  }

  export type DatasetsMinAggregateInputType = {
    id?: true
    project_id?: true
    filename?: true
    original_name?: true
    file_size?: true
    row_count?: true
    created_at?: true
  }

  export type DatasetsMaxAggregateInputType = {
    id?: true
    project_id?: true
    filename?: true
    original_name?: true
    file_size?: true
    row_count?: true
    created_at?: true
  }

  export type DatasetsCountAggregateInputType = {
    id?: true
    project_id?: true
    filename?: true
    original_name?: true
    file_size?: true
    columns?: true
    row_count?: true
    metadata?: true
    created_at?: true
    _all?: true
  }

  export type DatasetsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which datasets to aggregate.
     */
    where?: datasetsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of datasets to fetch.
     */
    orderBy?: datasetsOrderByWithRelationInput | datasetsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: datasetsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` datasets from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` datasets.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned datasets
    **/
    _count?: true | DatasetsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DatasetsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DatasetsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DatasetsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DatasetsMaxAggregateInputType
  }

  export type GetDatasetsAggregateType<T extends DatasetsAggregateArgs> = {
        [P in keyof T & keyof AggregateDatasets]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateDatasets[P]>
      : GetScalarType<T[P], AggregateDatasets[P]>
  }




  export type datasetsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: datasetsWhereInput
    orderBy?: datasetsOrderByWithAggregationInput | datasetsOrderByWithAggregationInput[]
    by: DatasetsScalarFieldEnum[] | DatasetsScalarFieldEnum
    having?: datasetsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DatasetsCountAggregateInputType | true
    _avg?: DatasetsAvgAggregateInputType
    _sum?: DatasetsSumAggregateInputType
    _min?: DatasetsMinAggregateInputType
    _max?: DatasetsMaxAggregateInputType
  }

  export type DatasetsGroupByOutputType = {
    id: string
    project_id: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonValue
    row_count: number
    metadata: JsonValue | null
    created_at: Date
    _count: DatasetsCountAggregateOutputType | null
    _avg: DatasetsAvgAggregateOutputType | null
    _sum: DatasetsSumAggregateOutputType | null
    _min: DatasetsMinAggregateOutputType | null
    _max: DatasetsMaxAggregateOutputType | null
  }

  type GetDatasetsGroupByPayload<T extends datasetsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<DatasetsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof DatasetsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], DatasetsGroupByOutputType[P]>
            : GetScalarType<T[P], DatasetsGroupByOutputType[P]>
        }
      >
    >


  export type datasetsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    filename?: boolean
    original_name?: boolean
    file_size?: boolean
    columns?: boolean
    row_count?: boolean
    metadata?: boolean
    created_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    analyses?: boolean | datasets$analysesArgs<ExtArgs>
    _count?: boolean | DatasetsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["datasets"]>

  export type datasetsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    filename?: boolean
    original_name?: boolean
    file_size?: boolean
    columns?: boolean
    row_count?: boolean
    metadata?: boolean
    created_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["datasets"]>

  export type datasetsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    filename?: boolean
    original_name?: boolean
    file_size?: boolean
    columns?: boolean
    row_count?: boolean
    metadata?: boolean
    created_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["datasets"]>

  export type datasetsSelectScalar = {
    id?: boolean
    project_id?: boolean
    filename?: boolean
    original_name?: boolean
    file_size?: boolean
    columns?: boolean
    row_count?: boolean
    metadata?: boolean
    created_at?: boolean
  }

  export type datasetsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "project_id" | "filename" | "original_name" | "file_size" | "columns" | "row_count" | "metadata" | "created_at", ExtArgs["result"]["datasets"]>
  export type datasetsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    analyses?: boolean | datasets$analysesArgs<ExtArgs>
    _count?: boolean | DatasetsCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type datasetsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
  }
  export type datasetsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
  }

  export type $datasetsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "datasets"
    objects: {
      projects: Prisma.$projectsPayload<ExtArgs>
      analyses: Prisma.$analysesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      project_id: string
      filename: string
      original_name: string
      file_size: number
      columns: Prisma.JsonValue
      row_count: number
      metadata: Prisma.JsonValue | null
      created_at: Date
    }, ExtArgs["result"]["datasets"]>
    composites: {}
  }

  type datasetsGetPayload<S extends boolean | null | undefined | datasetsDefaultArgs> = $Result.GetResult<Prisma.$datasetsPayload, S>

  type datasetsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<datasetsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: DatasetsCountAggregateInputType | true
    }

  export interface datasetsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['datasets'], meta: { name: 'datasets' } }
    /**
     * Find zero or one Datasets that matches the filter.
     * @param {datasetsFindUniqueArgs} args - Arguments to find a Datasets
     * @example
     * // Get one Datasets
     * const datasets = await prisma.datasets.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends datasetsFindUniqueArgs>(args: SelectSubset<T, datasetsFindUniqueArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Datasets that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {datasetsFindUniqueOrThrowArgs} args - Arguments to find a Datasets
     * @example
     * // Get one Datasets
     * const datasets = await prisma.datasets.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends datasetsFindUniqueOrThrowArgs>(args: SelectSubset<T, datasetsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Datasets 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 {datasetsFindFirstArgs} args - Arguments to find a Datasets
     * @example
     * // Get one Datasets
     * const datasets = await prisma.datasets.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends datasetsFindFirstArgs>(args?: SelectSubset<T, datasetsFindFirstArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Datasets 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 {datasetsFindFirstOrThrowArgs} args - Arguments to find a Datasets
     * @example
     * // Get one Datasets
     * const datasets = await prisma.datasets.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends datasetsFindFirstOrThrowArgs>(args?: SelectSubset<T, datasetsFindFirstOrThrowArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Datasets 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 {datasetsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Datasets
     * const datasets = await prisma.datasets.findMany()
     * 
     * // Get first 10 Datasets
     * const datasets = await prisma.datasets.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const datasetsWithIdOnly = await prisma.datasets.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends datasetsFindManyArgs>(args?: SelectSubset<T, datasetsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Datasets.
     * @param {datasetsCreateArgs} args - Arguments to create a Datasets.
     * @example
     * // Create one Datasets
     * const Datasets = await prisma.datasets.create({
     *   data: {
     *     // ... data to create a Datasets
     *   }
     * })
     * 
     */
    create<T extends datasetsCreateArgs>(args: SelectSubset<T, datasetsCreateArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Datasets.
     * @param {datasetsCreateManyArgs} args - Arguments to create many Datasets.
     * @example
     * // Create many Datasets
     * const datasets = await prisma.datasets.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends datasetsCreateManyArgs>(args?: SelectSubset<T, datasetsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Datasets and returns the data saved in the database.
     * @param {datasetsCreateManyAndReturnArgs} args - Arguments to create many Datasets.
     * @example
     * // Create many Datasets
     * const datasets = await prisma.datasets.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Datasets and only return the `id`
     * const datasetsWithIdOnly = await prisma.datasets.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 datasetsCreateManyAndReturnArgs>(args?: SelectSubset<T, datasetsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Datasets.
     * @param {datasetsDeleteArgs} args - Arguments to delete one Datasets.
     * @example
     * // Delete one Datasets
     * const Datasets = await prisma.datasets.delete({
     *   where: {
     *     // ... filter to delete one Datasets
     *   }
     * })
     * 
     */
    delete<T extends datasetsDeleteArgs>(args: SelectSubset<T, datasetsDeleteArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Datasets.
     * @param {datasetsUpdateArgs} args - Arguments to update one Datasets.
     * @example
     * // Update one Datasets
     * const datasets = await prisma.datasets.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends datasetsUpdateArgs>(args: SelectSubset<T, datasetsUpdateArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Datasets.
     * @param {datasetsDeleteManyArgs} args - Arguments to filter Datasets to delete.
     * @example
     * // Delete a few Datasets
     * const { count } = await prisma.datasets.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends datasetsDeleteManyArgs>(args?: SelectSubset<T, datasetsDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Datasets.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {datasetsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Datasets
     * const datasets = await prisma.datasets.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends datasetsUpdateManyArgs>(args: SelectSubset<T, datasetsUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Datasets and returns the data updated in the database.
     * @param {datasetsUpdateManyAndReturnArgs} args - Arguments to update many Datasets.
     * @example
     * // Update many Datasets
     * const datasets = await prisma.datasets.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Datasets and only return the `id`
     * const datasetsWithIdOnly = await prisma.datasets.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends datasetsUpdateManyAndReturnArgs>(args: SelectSubset<T, datasetsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Datasets.
     * @param {datasetsUpsertArgs} args - Arguments to update or create a Datasets.
     * @example
     * // Update or create a Datasets
     * const datasets = await prisma.datasets.upsert({
     *   create: {
     *     // ... data to create a Datasets
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Datasets we want to update
     *   }
     * })
     */
    upsert<T extends datasetsUpsertArgs>(args: SelectSubset<T, datasetsUpsertArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Datasets.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {datasetsCountArgs} args - Arguments to filter Datasets to count.
     * @example
     * // Count the number of Datasets
     * const count = await prisma.datasets.count({
     *   where: {
     *     // ... the filter for the Datasets we want to count
     *   }
     * })
    **/
    count<T extends datasetsCountArgs>(
      args?: Subset<T, datasetsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], DatasetsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Datasets.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DatasetsAggregateArgs} 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 DatasetsAggregateArgs>(args: Subset<T, DatasetsAggregateArgs>): Prisma.PrismaPromise<GetDatasetsAggregateType<T>>

    /**
     * Group by Datasets.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {datasetsGroupByArgs} 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 datasetsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: datasetsGroupByArgs['orderBy'] }
        : { orderBy?: datasetsGroupByArgs['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, datasetsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDatasetsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the datasets model
   */
  readonly fields: datasetsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for datasets.
   * 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__datasetsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    projects<T extends projectsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, projectsDefaultArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    analyses<T extends datasets$analysesArgs<ExtArgs> = {}>(args?: Subset<T, datasets$analysesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the datasets model
   */
  interface datasetsFieldRefs {
    readonly id: FieldRef<"datasets", 'String'>
    readonly project_id: FieldRef<"datasets", 'String'>
    readonly filename: FieldRef<"datasets", 'String'>
    readonly original_name: FieldRef<"datasets", 'String'>
    readonly file_size: FieldRef<"datasets", 'Int'>
    readonly columns: FieldRef<"datasets", 'Json'>
    readonly row_count: FieldRef<"datasets", 'Int'>
    readonly metadata: FieldRef<"datasets", 'Json'>
    readonly created_at: FieldRef<"datasets", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * datasets findUnique
   */
  export type datasetsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter, which datasets to fetch.
     */
    where: datasetsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets findUniqueOrThrow
   */
  export type datasetsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter, which datasets to fetch.
     */
    where: datasetsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets findFirst
   */
  export type datasetsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter, which datasets to fetch.
     */
    where?: datasetsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of datasets to fetch.
     */
    orderBy?: datasetsOrderByWithRelationInput | datasetsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for datasets.
     */
    cursor?: datasetsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` datasets from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` datasets.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of datasets.
     */
    distinct?: DatasetsScalarFieldEnum | DatasetsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets findFirstOrThrow
   */
  export type datasetsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter, which datasets to fetch.
     */
    where?: datasetsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of datasets to fetch.
     */
    orderBy?: datasetsOrderByWithRelationInput | datasetsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for datasets.
     */
    cursor?: datasetsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` datasets from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` datasets.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of datasets.
     */
    distinct?: DatasetsScalarFieldEnum | DatasetsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets findMany
   */
  export type datasetsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter, which datasets to fetch.
     */
    where?: datasetsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of datasets to fetch.
     */
    orderBy?: datasetsOrderByWithRelationInput | datasetsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing datasets.
     */
    cursor?: datasetsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` datasets from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` datasets.
     */
    skip?: number
    distinct?: DatasetsScalarFieldEnum | DatasetsScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets create
   */
  export type datasetsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * The data needed to create a datasets.
     */
    data: XOR<datasetsCreateInput, datasetsUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets createMany
   */
  export type datasetsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many datasets.
     */
    data: datasetsCreateManyInput | datasetsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * datasets createManyAndReturn
   */
  export type datasetsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * The data used to create many datasets.
     */
    data: datasetsCreateManyInput | datasetsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * datasets update
   */
  export type datasetsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * The data needed to update a datasets.
     */
    data: XOR<datasetsUpdateInput, datasetsUncheckedUpdateInput>
    /**
     * Choose, which datasets to update.
     */
    where: datasetsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets updateMany
   */
  export type datasetsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update datasets.
     */
    data: XOR<datasetsUpdateManyMutationInput, datasetsUncheckedUpdateManyInput>
    /**
     * Filter which datasets to update
     */
    where?: datasetsWhereInput
    /**
     * Limit how many datasets to update.
     */
    limit?: number
  }

  /**
   * datasets updateManyAndReturn
   */
  export type datasetsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * The data used to update datasets.
     */
    data: XOR<datasetsUpdateManyMutationInput, datasetsUncheckedUpdateManyInput>
    /**
     * Filter which datasets to update
     */
    where?: datasetsWhereInput
    /**
     * Limit how many datasets to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * datasets upsert
   */
  export type datasetsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * The filter to search for the datasets to update in case it exists.
     */
    where: datasetsWhereUniqueInput
    /**
     * In case the datasets found by the `where` argument doesn't exist, create a new datasets with this data.
     */
    create: XOR<datasetsCreateInput, datasetsUncheckedCreateInput>
    /**
     * In case the datasets was found with the provided `where` argument, update it with this data.
     */
    update: XOR<datasetsUpdateInput, datasetsUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets delete
   */
  export type datasetsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
    /**
     * Filter which datasets to delete.
     */
    where: datasetsWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * datasets deleteMany
   */
  export type datasetsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which datasets to delete
     */
    where?: datasetsWhereInput
    /**
     * Limit how many datasets to delete.
     */
    limit?: number
  }

  /**
   * datasets.analyses
   */
  export type datasets$analysesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    where?: analysesWhereInput
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    cursor?: analysesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AnalysesScalarFieldEnum | AnalysesScalarFieldEnum[]
  }

  /**
   * datasets without action
   */
  export type datasetsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the datasets
     */
    select?: datasetsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the datasets
     */
    omit?: datasetsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: datasetsInclude<ExtArgs> | null
  }


  /**
   * Model analyses
   */

  export type AggregateAnalyses = {
    _count: AnalysesCountAggregateOutputType | null
    _min: AnalysesMinAggregateOutputType | null
    _max: AnalysesMaxAggregateOutputType | null
  }

  export type AnalysesMinAggregateOutputType = {
    id: string | null
    project_id: string | null
    dataset_id: string | null
    name: string | null
    status: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type AnalysesMaxAggregateOutputType = {
    id: string | null
    project_id: string | null
    dataset_id: string | null
    name: string | null
    status: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type AnalysesCountAggregateOutputType = {
    id: number
    project_id: number
    dataset_id: number
    name: number
    config: number
    results: number
    status: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type AnalysesMinAggregateInputType = {
    id?: true
    project_id?: true
    dataset_id?: true
    name?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type AnalysesMaxAggregateInputType = {
    id?: true
    project_id?: true
    dataset_id?: true
    name?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type AnalysesCountAggregateInputType = {
    id?: true
    project_id?: true
    dataset_id?: true
    name?: true
    config?: true
    results?: true
    status?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type AnalysesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which analyses to aggregate.
     */
    where?: analysesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analyses to fetch.
     */
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: analysesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned analyses
    **/
    _count?: true | AnalysesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AnalysesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AnalysesMaxAggregateInputType
  }

  export type GetAnalysesAggregateType<T extends AnalysesAggregateArgs> = {
        [P in keyof T & keyof AggregateAnalyses]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAnalyses[P]>
      : GetScalarType<T[P], AggregateAnalyses[P]>
  }




  export type analysesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: analysesWhereInput
    orderBy?: analysesOrderByWithAggregationInput | analysesOrderByWithAggregationInput[]
    by: AnalysesScalarFieldEnum[] | AnalysesScalarFieldEnum
    having?: analysesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AnalysesCountAggregateInputType | true
    _min?: AnalysesMinAggregateInputType
    _max?: AnalysesMaxAggregateInputType
  }

  export type AnalysesGroupByOutputType = {
    id: string
    project_id: string
    dataset_id: string
    name: string
    config: JsonValue
    results: JsonValue | null
    status: string
    created_at: Date
    updated_at: Date
    _count: AnalysesCountAggregateOutputType | null
    _min: AnalysesMinAggregateOutputType | null
    _max: AnalysesMaxAggregateOutputType | null
  }

  type GetAnalysesGroupByPayload<T extends analysesGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AnalysesGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AnalysesGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AnalysesGroupByOutputType[P]>
            : GetScalarType<T[P], AnalysesGroupByOutputType[P]>
        }
      >
    >


  export type analysesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    dataset_id?: boolean
    name?: boolean
    config?: boolean
    results?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
    clusters?: boolean | analyses$clustersArgs<ExtArgs>
    _count?: boolean | AnalysesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analyses"]>

  export type analysesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    dataset_id?: boolean
    name?: boolean
    config?: boolean
    results?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analyses"]>

  export type analysesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    project_id?: boolean
    dataset_id?: boolean
    name?: boolean
    config?: boolean
    results?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analyses"]>

  export type analysesSelectScalar = {
    id?: boolean
    project_id?: boolean
    dataset_id?: boolean
    name?: boolean
    config?: boolean
    results?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type analysesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "project_id" | "dataset_id" | "name" | "config" | "results" | "status" | "created_at" | "updated_at", ExtArgs["result"]["analyses"]>
  export type analysesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
    clusters?: boolean | analyses$clustersArgs<ExtArgs>
    _count?: boolean | AnalysesCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type analysesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
  }
  export type analysesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    projects?: boolean | projectsDefaultArgs<ExtArgs>
    datasets?: boolean | datasetsDefaultArgs<ExtArgs>
  }

  export type $analysesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "analyses"
    objects: {
      projects: Prisma.$projectsPayload<ExtArgs>
      datasets: Prisma.$datasetsPayload<ExtArgs>
      clusters: Prisma.$clustersPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      project_id: string
      dataset_id: string
      name: string
      config: Prisma.JsonValue
      results: Prisma.JsonValue | null
      status: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["analyses"]>
    composites: {}
  }

  type analysesGetPayload<S extends boolean | null | undefined | analysesDefaultArgs> = $Result.GetResult<Prisma.$analysesPayload, S>

  type analysesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<analysesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: AnalysesCountAggregateInputType | true
    }

  export interface analysesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['analyses'], meta: { name: 'analyses' } }
    /**
     * Find zero or one Analyses that matches the filter.
     * @param {analysesFindUniqueArgs} args - Arguments to find a Analyses
     * @example
     * // Get one Analyses
     * const analyses = await prisma.analyses.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends analysesFindUniqueArgs>(args: SelectSubset<T, analysesFindUniqueArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Analyses that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {analysesFindUniqueOrThrowArgs} args - Arguments to find a Analyses
     * @example
     * // Get one Analyses
     * const analyses = await prisma.analyses.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends analysesFindUniqueOrThrowArgs>(args: SelectSubset<T, analysesFindUniqueOrThrowArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Analyses 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 {analysesFindFirstArgs} args - Arguments to find a Analyses
     * @example
     * // Get one Analyses
     * const analyses = await prisma.analyses.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends analysesFindFirstArgs>(args?: SelectSubset<T, analysesFindFirstArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Analyses 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 {analysesFindFirstOrThrowArgs} args - Arguments to find a Analyses
     * @example
     * // Get one Analyses
     * const analyses = await prisma.analyses.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends analysesFindFirstOrThrowArgs>(args?: SelectSubset<T, analysesFindFirstOrThrowArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Analyses 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 {analysesFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Analyses
     * const analyses = await prisma.analyses.findMany()
     * 
     * // Get first 10 Analyses
     * const analyses = await prisma.analyses.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const analysesWithIdOnly = await prisma.analyses.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends analysesFindManyArgs>(args?: SelectSubset<T, analysesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Analyses.
     * @param {analysesCreateArgs} args - Arguments to create a Analyses.
     * @example
     * // Create one Analyses
     * const Analyses = await prisma.analyses.create({
     *   data: {
     *     // ... data to create a Analyses
     *   }
     * })
     * 
     */
    create<T extends analysesCreateArgs>(args: SelectSubset<T, analysesCreateArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Analyses.
     * @param {analysesCreateManyArgs} args - Arguments to create many Analyses.
     * @example
     * // Create many Analyses
     * const analyses = await prisma.analyses.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends analysesCreateManyArgs>(args?: SelectSubset<T, analysesCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Analyses and returns the data saved in the database.
     * @param {analysesCreateManyAndReturnArgs} args - Arguments to create many Analyses.
     * @example
     * // Create many Analyses
     * const analyses = await prisma.analyses.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Analyses and only return the `id`
     * const analysesWithIdOnly = await prisma.analyses.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 analysesCreateManyAndReturnArgs>(args?: SelectSubset<T, analysesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Analyses.
     * @param {analysesDeleteArgs} args - Arguments to delete one Analyses.
     * @example
     * // Delete one Analyses
     * const Analyses = await prisma.analyses.delete({
     *   where: {
     *     // ... filter to delete one Analyses
     *   }
     * })
     * 
     */
    delete<T extends analysesDeleteArgs>(args: SelectSubset<T, analysesDeleteArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Analyses.
     * @param {analysesUpdateArgs} args - Arguments to update one Analyses.
     * @example
     * // Update one Analyses
     * const analyses = await prisma.analyses.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends analysesUpdateArgs>(args: SelectSubset<T, analysesUpdateArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Analyses.
     * @param {analysesDeleteManyArgs} args - Arguments to filter Analyses to delete.
     * @example
     * // Delete a few Analyses
     * const { count } = await prisma.analyses.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends analysesDeleteManyArgs>(args?: SelectSubset<T, analysesDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Analyses.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysesUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Analyses
     * const analyses = await prisma.analyses.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends analysesUpdateManyArgs>(args: SelectSubset<T, analysesUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Analyses and returns the data updated in the database.
     * @param {analysesUpdateManyAndReturnArgs} args - Arguments to update many Analyses.
     * @example
     * // Update many Analyses
     * const analyses = await prisma.analyses.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Analyses and only return the `id`
     * const analysesWithIdOnly = await prisma.analyses.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends analysesUpdateManyAndReturnArgs>(args: SelectSubset<T, analysesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Analyses.
     * @param {analysesUpsertArgs} args - Arguments to update or create a Analyses.
     * @example
     * // Update or create a Analyses
     * const analyses = await prisma.analyses.upsert({
     *   create: {
     *     // ... data to create a Analyses
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Analyses we want to update
     *   }
     * })
     */
    upsert<T extends analysesUpsertArgs>(args: SelectSubset<T, analysesUpsertArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Analyses.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysesCountArgs} args - Arguments to filter Analyses to count.
     * @example
     * // Count the number of Analyses
     * const count = await prisma.analyses.count({
     *   where: {
     *     // ... the filter for the Analyses we want to count
     *   }
     * })
    **/
    count<T extends analysesCountArgs>(
      args?: Subset<T, analysesCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AnalysesCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Analyses.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AnalysesAggregateArgs} 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 AnalysesAggregateArgs>(args: Subset<T, AnalysesAggregateArgs>): Prisma.PrismaPromise<GetAnalysesAggregateType<T>>

    /**
     * Group by Analyses.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysesGroupByArgs} 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 analysesGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: analysesGroupByArgs['orderBy'] }
        : { orderBy?: analysesGroupByArgs['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, analysesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAnalysesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the analyses model
   */
  readonly fields: analysesFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for analyses.
   * 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__analysesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    projects<T extends projectsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, projectsDefaultArgs<ExtArgs>>): Prisma__projectsClient<$Result.GetResult<Prisma.$projectsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    datasets<T extends datasetsDefaultArgs<ExtArgs> = {}>(args?: Subset<T, datasetsDefaultArgs<ExtArgs>>): Prisma__datasetsClient<$Result.GetResult<Prisma.$datasetsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    clusters<T extends analyses$clustersArgs<ExtArgs> = {}>(args?: Subset<T, analyses$clustersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the analyses model
   */
  interface analysesFieldRefs {
    readonly id: FieldRef<"analyses", 'String'>
    readonly project_id: FieldRef<"analyses", 'String'>
    readonly dataset_id: FieldRef<"analyses", 'String'>
    readonly name: FieldRef<"analyses", 'String'>
    readonly config: FieldRef<"analyses", 'Json'>
    readonly results: FieldRef<"analyses", 'Json'>
    readonly status: FieldRef<"analyses", 'String'>
    readonly created_at: FieldRef<"analyses", 'DateTime'>
    readonly updated_at: FieldRef<"analyses", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * analyses findUnique
   */
  export type analysesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter, which analyses to fetch.
     */
    where: analysesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses findUniqueOrThrow
   */
  export type analysesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter, which analyses to fetch.
     */
    where: analysesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses findFirst
   */
  export type analysesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter, which analyses to fetch.
     */
    where?: analysesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analyses to fetch.
     */
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for analyses.
     */
    cursor?: analysesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of analyses.
     */
    distinct?: AnalysesScalarFieldEnum | AnalysesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses findFirstOrThrow
   */
  export type analysesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter, which analyses to fetch.
     */
    where?: analysesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analyses to fetch.
     */
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for analyses.
     */
    cursor?: analysesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analyses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of analyses.
     */
    distinct?: AnalysesScalarFieldEnum | AnalysesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses findMany
   */
  export type analysesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter, which analyses to fetch.
     */
    where?: analysesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analyses to fetch.
     */
    orderBy?: analysesOrderByWithRelationInput | analysesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing analyses.
     */
    cursor?: analysesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analyses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analyses.
     */
    skip?: number
    distinct?: AnalysesScalarFieldEnum | AnalysesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses create
   */
  export type analysesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * The data needed to create a analyses.
     */
    data: XOR<analysesCreateInput, analysesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses createMany
   */
  export type analysesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many analyses.
     */
    data: analysesCreateManyInput | analysesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * analyses createManyAndReturn
   */
  export type analysesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * The data used to create many analyses.
     */
    data: analysesCreateManyInput | analysesCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * analyses update
   */
  export type analysesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * The data needed to update a analyses.
     */
    data: XOR<analysesUpdateInput, analysesUncheckedUpdateInput>
    /**
     * Choose, which analyses to update.
     */
    where: analysesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses updateMany
   */
  export type analysesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update analyses.
     */
    data: XOR<analysesUpdateManyMutationInput, analysesUncheckedUpdateManyInput>
    /**
     * Filter which analyses to update
     */
    where?: analysesWhereInput
    /**
     * Limit how many analyses to update.
     */
    limit?: number
  }

  /**
   * analyses updateManyAndReturn
   */
  export type analysesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * The data used to update analyses.
     */
    data: XOR<analysesUpdateManyMutationInput, analysesUncheckedUpdateManyInput>
    /**
     * Filter which analyses to update
     */
    where?: analysesWhereInput
    /**
     * Limit how many analyses to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * analyses upsert
   */
  export type analysesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * The filter to search for the analyses to update in case it exists.
     */
    where: analysesWhereUniqueInput
    /**
     * In case the analyses found by the `where` argument doesn't exist, create a new analyses with this data.
     */
    create: XOR<analysesCreateInput, analysesUncheckedCreateInput>
    /**
     * In case the analyses was found with the provided `where` argument, update it with this data.
     */
    update: XOR<analysesUpdateInput, analysesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses delete
   */
  export type analysesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
    /**
     * Filter which analyses to delete.
     */
    where: analysesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analyses deleteMany
   */
  export type analysesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which analyses to delete
     */
    where?: analysesWhereInput
    /**
     * Limit how many analyses to delete.
     */
    limit?: number
  }

  /**
   * analyses.clusters
   */
  export type analyses$clustersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    where?: clustersWhereInput
    orderBy?: clustersOrderByWithRelationInput | clustersOrderByWithRelationInput[]
    cursor?: clustersWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ClustersScalarFieldEnum | ClustersScalarFieldEnum[]
  }

  /**
   * analyses without action
   */
  export type analysesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analyses
     */
    select?: analysesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analyses
     */
    omit?: analysesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: analysesInclude<ExtArgs> | null
  }


  /**
   * Model clusters
   */

  export type AggregateClusters = {
    _count: ClustersCountAggregateOutputType | null
    _avg: ClustersAvgAggregateOutputType | null
    _sum: ClustersSumAggregateOutputType | null
    _min: ClustersMinAggregateOutputType | null
    _max: ClustersMaxAggregateOutputType | null
  }

  export type ClustersAvgAggregateOutputType = {
    cluster_id: number | null
    point_count: number | null
  }

  export type ClustersSumAggregateOutputType = {
    cluster_id: number | null
    point_count: number | null
  }

  export type ClustersMinAggregateOutputType = {
    id: string | null
    analysis_id: string | null
    cluster_id: number | null
    point_count: number | null
  }

  export type ClustersMaxAggregateOutputType = {
    id: string | null
    analysis_id: string | null
    cluster_id: number | null
    point_count: number | null
  }

  export type ClustersCountAggregateOutputType = {
    id: number
    analysis_id: number
    cluster_id: number
    center_data: number
    point_count: number
    characteristics: number
    _all: number
  }


  export type ClustersAvgAggregateInputType = {
    cluster_id?: true
    point_count?: true
  }

  export type ClustersSumAggregateInputType = {
    cluster_id?: true
    point_count?: true
  }

  export type ClustersMinAggregateInputType = {
    id?: true
    analysis_id?: true
    cluster_id?: true
    point_count?: true
  }

  export type ClustersMaxAggregateInputType = {
    id?: true
    analysis_id?: true
    cluster_id?: true
    point_count?: true
  }

  export type ClustersCountAggregateInputType = {
    id?: true
    analysis_id?: true
    cluster_id?: true
    center_data?: true
    point_count?: true
    characteristics?: true
    _all?: true
  }

  export type ClustersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which clusters to aggregate.
     */
    where?: clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of clusters to fetch.
     */
    orderBy?: clustersOrderByWithRelationInput | clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` clusters.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned clusters
    **/
    _count?: true | ClustersCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ClustersAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ClustersSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ClustersMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ClustersMaxAggregateInputType
  }

  export type GetClustersAggregateType<T extends ClustersAggregateArgs> = {
        [P in keyof T & keyof AggregateClusters]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateClusters[P]>
      : GetScalarType<T[P], AggregateClusters[P]>
  }




  export type clustersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: clustersWhereInput
    orderBy?: clustersOrderByWithAggregationInput | clustersOrderByWithAggregationInput[]
    by: ClustersScalarFieldEnum[] | ClustersScalarFieldEnum
    having?: clustersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ClustersCountAggregateInputType | true
    _avg?: ClustersAvgAggregateInputType
    _sum?: ClustersSumAggregateInputType
    _min?: ClustersMinAggregateInputType
    _max?: ClustersMaxAggregateInputType
  }

  export type ClustersGroupByOutputType = {
    id: string
    analysis_id: string
    cluster_id: number
    center_data: JsonValue
    point_count: number
    characteristics: JsonValue | null
    _count: ClustersCountAggregateOutputType | null
    _avg: ClustersAvgAggregateOutputType | null
    _sum: ClustersSumAggregateOutputType | null
    _min: ClustersMinAggregateOutputType | null
    _max: ClustersMaxAggregateOutputType | null
  }

  type GetClustersGroupByPayload<T extends clustersGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ClustersGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ClustersGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ClustersGroupByOutputType[P]>
            : GetScalarType<T[P], ClustersGroupByOutputType[P]>
        }
      >
    >


  export type clustersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    analysis_id?: boolean
    cluster_id?: boolean
    center_data?: boolean
    point_count?: boolean
    characteristics?: boolean
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["clusters"]>

  export type clustersSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    analysis_id?: boolean
    cluster_id?: boolean
    center_data?: boolean
    point_count?: boolean
    characteristics?: boolean
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["clusters"]>

  export type clustersSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    analysis_id?: boolean
    cluster_id?: boolean
    center_data?: boolean
    point_count?: boolean
    characteristics?: boolean
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["clusters"]>

  export type clustersSelectScalar = {
    id?: boolean
    analysis_id?: boolean
    cluster_id?: boolean
    center_data?: boolean
    point_count?: boolean
    characteristics?: boolean
  }

  export type clustersOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "analysis_id" | "cluster_id" | "center_data" | "point_count" | "characteristics", ExtArgs["result"]["clusters"]>
  export type clustersInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }
  export type clustersIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }
  export type clustersIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    analyses?: boolean | analysesDefaultArgs<ExtArgs>
  }

  export type $clustersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "clusters"
    objects: {
      analyses: Prisma.$analysesPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      analysis_id: string
      cluster_id: number
      center_data: Prisma.JsonValue
      point_count: number
      characteristics: Prisma.JsonValue | null
    }, ExtArgs["result"]["clusters"]>
    composites: {}
  }

  type clustersGetPayload<S extends boolean | null | undefined | clustersDefaultArgs> = $Result.GetResult<Prisma.$clustersPayload, S>

  type clustersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<clustersFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: ClustersCountAggregateInputType | true
    }

  export interface clustersDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['clusters'], meta: { name: 'clusters' } }
    /**
     * Find zero or one Clusters that matches the filter.
     * @param {clustersFindUniqueArgs} args - Arguments to find a Clusters
     * @example
     * // Get one Clusters
     * const clusters = await prisma.clusters.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends clustersFindUniqueArgs>(args: SelectSubset<T, clustersFindUniqueArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Clusters that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {clustersFindUniqueOrThrowArgs} args - Arguments to find a Clusters
     * @example
     * // Get one Clusters
     * const clusters = await prisma.clusters.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends clustersFindUniqueOrThrowArgs>(args: SelectSubset<T, clustersFindUniqueOrThrowArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Clusters 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 {clustersFindFirstArgs} args - Arguments to find a Clusters
     * @example
     * // Get one Clusters
     * const clusters = await prisma.clusters.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends clustersFindFirstArgs>(args?: SelectSubset<T, clustersFindFirstArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Clusters 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 {clustersFindFirstOrThrowArgs} args - Arguments to find a Clusters
     * @example
     * // Get one Clusters
     * const clusters = await prisma.clusters.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends clustersFindFirstOrThrowArgs>(args?: SelectSubset<T, clustersFindFirstOrThrowArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Clusters 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 {clustersFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Clusters
     * const clusters = await prisma.clusters.findMany()
     * 
     * // Get first 10 Clusters
     * const clusters = await prisma.clusters.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const clustersWithIdOnly = await prisma.clusters.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends clustersFindManyArgs>(args?: SelectSubset<T, clustersFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Clusters.
     * @param {clustersCreateArgs} args - Arguments to create a Clusters.
     * @example
     * // Create one Clusters
     * const Clusters = await prisma.clusters.create({
     *   data: {
     *     // ... data to create a Clusters
     *   }
     * })
     * 
     */
    create<T extends clustersCreateArgs>(args: SelectSubset<T, clustersCreateArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Clusters.
     * @param {clustersCreateManyArgs} args - Arguments to create many Clusters.
     * @example
     * // Create many Clusters
     * const clusters = await prisma.clusters.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends clustersCreateManyArgs>(args?: SelectSubset<T, clustersCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Clusters and returns the data saved in the database.
     * @param {clustersCreateManyAndReturnArgs} args - Arguments to create many Clusters.
     * @example
     * // Create many Clusters
     * const clusters = await prisma.clusters.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Clusters and only return the `id`
     * const clustersWithIdOnly = await prisma.clusters.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 clustersCreateManyAndReturnArgs>(args?: SelectSubset<T, clustersCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Clusters.
     * @param {clustersDeleteArgs} args - Arguments to delete one Clusters.
     * @example
     * // Delete one Clusters
     * const Clusters = await prisma.clusters.delete({
     *   where: {
     *     // ... filter to delete one Clusters
     *   }
     * })
     * 
     */
    delete<T extends clustersDeleteArgs>(args: SelectSubset<T, clustersDeleteArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Clusters.
     * @param {clustersUpdateArgs} args - Arguments to update one Clusters.
     * @example
     * // Update one Clusters
     * const clusters = await prisma.clusters.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends clustersUpdateArgs>(args: SelectSubset<T, clustersUpdateArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Clusters.
     * @param {clustersDeleteManyArgs} args - Arguments to filter Clusters to delete.
     * @example
     * // Delete a few Clusters
     * const { count } = await prisma.clusters.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends clustersDeleteManyArgs>(args?: SelectSubset<T, clustersDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Clusters.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {clustersUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Clusters
     * const clusters = await prisma.clusters.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends clustersUpdateManyArgs>(args: SelectSubset<T, clustersUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Clusters and returns the data updated in the database.
     * @param {clustersUpdateManyAndReturnArgs} args - Arguments to update many Clusters.
     * @example
     * // Update many Clusters
     * const clusters = await prisma.clusters.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Clusters and only return the `id`
     * const clustersWithIdOnly = await prisma.clusters.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends clustersUpdateManyAndReturnArgs>(args: SelectSubset<T, clustersUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Clusters.
     * @param {clustersUpsertArgs} args - Arguments to update or create a Clusters.
     * @example
     * // Update or create a Clusters
     * const clusters = await prisma.clusters.upsert({
     *   create: {
     *     // ... data to create a Clusters
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Clusters we want to update
     *   }
     * })
     */
    upsert<T extends clustersUpsertArgs>(args: SelectSubset<T, clustersUpsertArgs<ExtArgs>>): Prisma__clustersClient<$Result.GetResult<Prisma.$clustersPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Clusters.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {clustersCountArgs} args - Arguments to filter Clusters to count.
     * @example
     * // Count the number of Clusters
     * const count = await prisma.clusters.count({
     *   where: {
     *     // ... the filter for the Clusters we want to count
     *   }
     * })
    **/
    count<T extends clustersCountArgs>(
      args?: Subset<T, clustersCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ClustersCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Clusters.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ClustersAggregateArgs} 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 ClustersAggregateArgs>(args: Subset<T, ClustersAggregateArgs>): Prisma.PrismaPromise<GetClustersAggregateType<T>>

    /**
     * Group by Clusters.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {clustersGroupByArgs} 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 clustersGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: clustersGroupByArgs['orderBy'] }
        : { orderBy?: clustersGroupByArgs['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, clustersGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetClustersGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the clusters model
   */
  readonly fields: clustersFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for clusters.
   * 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__clustersClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    analyses<T extends analysesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, analysesDefaultArgs<ExtArgs>>): Prisma__analysesClient<$Result.GetResult<Prisma.$analysesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the clusters model
   */
  interface clustersFieldRefs {
    readonly id: FieldRef<"clusters", 'String'>
    readonly analysis_id: FieldRef<"clusters", 'String'>
    readonly cluster_id: FieldRef<"clusters", 'Int'>
    readonly center_data: FieldRef<"clusters", 'Json'>
    readonly point_count: FieldRef<"clusters", 'Int'>
    readonly characteristics: FieldRef<"clusters", 'Json'>
  }
    

  // Custom InputTypes
  /**
   * clusters findUnique
   */
  export type clustersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter, which clusters to fetch.
     */
    where: clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters findUniqueOrThrow
   */
  export type clustersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter, which clusters to fetch.
     */
    where: clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters findFirst
   */
  export type clustersFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter, which clusters to fetch.
     */
    where?: clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of clusters to fetch.
     */
    orderBy?: clustersOrderByWithRelationInput | clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for clusters.
     */
    cursor?: clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` clusters.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of clusters.
     */
    distinct?: ClustersScalarFieldEnum | ClustersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters findFirstOrThrow
   */
  export type clustersFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter, which clusters to fetch.
     */
    where?: clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of clusters to fetch.
     */
    orderBy?: clustersOrderByWithRelationInput | clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for clusters.
     */
    cursor?: clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` clusters.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of clusters.
     */
    distinct?: ClustersScalarFieldEnum | ClustersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters findMany
   */
  export type clustersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter, which clusters to fetch.
     */
    where?: clustersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of clusters to fetch.
     */
    orderBy?: clustersOrderByWithRelationInput | clustersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing clusters.
     */
    cursor?: clustersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` clusters from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` clusters.
     */
    skip?: number
    distinct?: ClustersScalarFieldEnum | ClustersScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters create
   */
  export type clustersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * The data needed to create a clusters.
     */
    data: XOR<clustersCreateInput, clustersUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters createMany
   */
  export type clustersCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many clusters.
     */
    data: clustersCreateManyInput | clustersCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * clusters createManyAndReturn
   */
  export type clustersCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * The data used to create many clusters.
     */
    data: clustersCreateManyInput | clustersCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * clusters update
   */
  export type clustersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * The data needed to update a clusters.
     */
    data: XOR<clustersUpdateInput, clustersUncheckedUpdateInput>
    /**
     * Choose, which clusters to update.
     */
    where: clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters updateMany
   */
  export type clustersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update clusters.
     */
    data: XOR<clustersUpdateManyMutationInput, clustersUncheckedUpdateManyInput>
    /**
     * Filter which clusters to update
     */
    where?: clustersWhereInput
    /**
     * Limit how many clusters to update.
     */
    limit?: number
  }

  /**
   * clusters updateManyAndReturn
   */
  export type clustersUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * The data used to update clusters.
     */
    data: XOR<clustersUpdateManyMutationInput, clustersUncheckedUpdateManyInput>
    /**
     * Filter which clusters to update
     */
    where?: clustersWhereInput
    /**
     * Limit how many clusters to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * clusters upsert
   */
  export type clustersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * The filter to search for the clusters to update in case it exists.
     */
    where: clustersWhereUniqueInput
    /**
     * In case the clusters found by the `where` argument doesn't exist, create a new clusters with this data.
     */
    create: XOR<clustersCreateInput, clustersUncheckedCreateInput>
    /**
     * In case the clusters was found with the provided `where` argument, update it with this data.
     */
    update: XOR<clustersUpdateInput, clustersUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters delete
   */
  export type clustersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
    /**
     * Filter which clusters to delete.
     */
    where: clustersWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * clusters deleteMany
   */
  export type clustersDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which clusters to delete
     */
    where?: clustersWhereInput
    /**
     * Limit how many clusters to delete.
     */
    limit?: number
  }

  /**
   * clusters without action
   */
  export type clustersDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the clusters
     */
    select?: clustersSelect<ExtArgs> | null
    /**
     * Omit specific fields from the clusters
     */
    omit?: clustersOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: clustersInclude<ExtArgs> | null
  }


  /**
   * Model analysis_templates
   */

  export type AggregateAnalysis_templates = {
    _count: Analysis_templatesCountAggregateOutputType | null
    _min: Analysis_templatesMinAggregateOutputType | null
    _max: Analysis_templatesMaxAggregateOutputType | null
  }

  export type Analysis_templatesMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    user_id: string | null
    is_public: boolean | null
    created_at: Date | null
  }

  export type Analysis_templatesMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    user_id: string | null
    is_public: boolean | null
    created_at: Date | null
  }

  export type Analysis_templatesCountAggregateOutputType = {
    id: number
    name: number
    description: number
    config: number
    user_id: number
    is_public: number
    created_at: number
    _all: number
  }


  export type Analysis_templatesMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    user_id?: true
    is_public?: true
    created_at?: true
  }

  export type Analysis_templatesMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    user_id?: true
    is_public?: true
    created_at?: true
  }

  export type Analysis_templatesCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    config?: true
    user_id?: true
    is_public?: true
    created_at?: true
    _all?: true
  }

  export type Analysis_templatesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which analysis_templates to aggregate.
     */
    where?: analysis_templatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analysis_templates to fetch.
     */
    orderBy?: analysis_templatesOrderByWithRelationInput | analysis_templatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: analysis_templatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analysis_templates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analysis_templates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned analysis_templates
    **/
    _count?: true | Analysis_templatesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Analysis_templatesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Analysis_templatesMaxAggregateInputType
  }

  export type GetAnalysis_templatesAggregateType<T extends Analysis_templatesAggregateArgs> = {
        [P in keyof T & keyof AggregateAnalysis_templates]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAnalysis_templates[P]>
      : GetScalarType<T[P], AggregateAnalysis_templates[P]>
  }




  export type analysis_templatesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: analysis_templatesWhereInput
    orderBy?: analysis_templatesOrderByWithAggregationInput | analysis_templatesOrderByWithAggregationInput[]
    by: Analysis_templatesScalarFieldEnum[] | Analysis_templatesScalarFieldEnum
    having?: analysis_templatesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Analysis_templatesCountAggregateInputType | true
    _min?: Analysis_templatesMinAggregateInputType
    _max?: Analysis_templatesMaxAggregateInputType
  }

  export type Analysis_templatesGroupByOutputType = {
    id: string
    name: string
    description: string | null
    config: JsonValue
    user_id: string
    is_public: boolean
    created_at: Date
    _count: Analysis_templatesCountAggregateOutputType | null
    _min: Analysis_templatesMinAggregateOutputType | null
    _max: Analysis_templatesMaxAggregateOutputType | null
  }

  type GetAnalysis_templatesGroupByPayload<T extends analysis_templatesGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Analysis_templatesGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Analysis_templatesGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Analysis_templatesGroupByOutputType[P]>
            : GetScalarType<T[P], Analysis_templatesGroupByOutputType[P]>
        }
      >
    >


  export type analysis_templatesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    config?: boolean
    user_id?: boolean
    is_public?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["analysis_templates"]>

  export type analysis_templatesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    config?: boolean
    user_id?: boolean
    is_public?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["analysis_templates"]>

  export type analysis_templatesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    config?: boolean
    user_id?: boolean
    is_public?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["analysis_templates"]>

  export type analysis_templatesSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    config?: boolean
    user_id?: boolean
    is_public?: boolean
    created_at?: boolean
  }

  export type analysis_templatesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "config" | "user_id" | "is_public" | "created_at", ExtArgs["result"]["analysis_templates"]>

  export type $analysis_templatesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "analysis_templates"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      config: Prisma.JsonValue
      user_id: string
      is_public: boolean
      created_at: Date
    }, ExtArgs["result"]["analysis_templates"]>
    composites: {}
  }

  type analysis_templatesGetPayload<S extends boolean | null | undefined | analysis_templatesDefaultArgs> = $Result.GetResult<Prisma.$analysis_templatesPayload, S>

  type analysis_templatesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<analysis_templatesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
      select?: Analysis_templatesCountAggregateInputType | true
    }

  export interface analysis_templatesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['analysis_templates'], meta: { name: 'analysis_templates' } }
    /**
     * Find zero or one Analysis_templates that matches the filter.
     * @param {analysis_templatesFindUniqueArgs} args - Arguments to find a Analysis_templates
     * @example
     * // Get one Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends analysis_templatesFindUniqueArgs>(args: SelectSubset<T, analysis_templatesFindUniqueArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Analysis_templates that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {analysis_templatesFindUniqueOrThrowArgs} args - Arguments to find a Analysis_templates
     * @example
     * // Get one Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends analysis_templatesFindUniqueOrThrowArgs>(args: SelectSubset<T, analysis_templatesFindUniqueOrThrowArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Analysis_templates 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 {analysis_templatesFindFirstArgs} args - Arguments to find a Analysis_templates
     * @example
     * // Get one Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends analysis_templatesFindFirstArgs>(args?: SelectSubset<T, analysis_templatesFindFirstArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Analysis_templates 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 {analysis_templatesFindFirstOrThrowArgs} args - Arguments to find a Analysis_templates
     * @example
     * // Get one Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends analysis_templatesFindFirstOrThrowArgs>(args?: SelectSubset<T, analysis_templatesFindFirstOrThrowArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Analysis_templates 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 {analysis_templatesFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findMany()
     * 
     * // Get first 10 Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const analysis_templatesWithIdOnly = await prisma.analysis_templates.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends analysis_templatesFindManyArgs>(args?: SelectSubset<T, analysis_templatesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Analysis_templates.
     * @param {analysis_templatesCreateArgs} args - Arguments to create a Analysis_templates.
     * @example
     * // Create one Analysis_templates
     * const Analysis_templates = await prisma.analysis_templates.create({
     *   data: {
     *     // ... data to create a Analysis_templates
     *   }
     * })
     * 
     */
    create<T extends analysis_templatesCreateArgs>(args: SelectSubset<T, analysis_templatesCreateArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Analysis_templates.
     * @param {analysis_templatesCreateManyArgs} args - Arguments to create many Analysis_templates.
     * @example
     * // Create many Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends analysis_templatesCreateManyArgs>(args?: SelectSubset<T, analysis_templatesCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Analysis_templates and returns the data saved in the database.
     * @param {analysis_templatesCreateManyAndReturnArgs} args - Arguments to create many Analysis_templates.
     * @example
     * // Create many Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Analysis_templates and only return the `id`
     * const analysis_templatesWithIdOnly = await prisma.analysis_templates.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 analysis_templatesCreateManyAndReturnArgs>(args?: SelectSubset<T, analysis_templatesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Analysis_templates.
     * @param {analysis_templatesDeleteArgs} args - Arguments to delete one Analysis_templates.
     * @example
     * // Delete one Analysis_templates
     * const Analysis_templates = await prisma.analysis_templates.delete({
     *   where: {
     *     // ... filter to delete one Analysis_templates
     *   }
     * })
     * 
     */
    delete<T extends analysis_templatesDeleteArgs>(args: SelectSubset<T, analysis_templatesDeleteArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Analysis_templates.
     * @param {analysis_templatesUpdateArgs} args - Arguments to update one Analysis_templates.
     * @example
     * // Update one Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends analysis_templatesUpdateArgs>(args: SelectSubset<T, analysis_templatesUpdateArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Analysis_templates.
     * @param {analysis_templatesDeleteManyArgs} args - Arguments to filter Analysis_templates to delete.
     * @example
     * // Delete a few Analysis_templates
     * const { count } = await prisma.analysis_templates.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends analysis_templatesDeleteManyArgs>(args?: SelectSubset<T, analysis_templatesDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Analysis_templates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysis_templatesUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends analysis_templatesUpdateManyArgs>(args: SelectSubset<T, analysis_templatesUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Analysis_templates and returns the data updated in the database.
     * @param {analysis_templatesUpdateManyAndReturnArgs} args - Arguments to update many Analysis_templates.
     * @example
     * // Update many Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Analysis_templates and only return the `id`
     * const analysis_templatesWithIdOnly = await prisma.analysis_templates.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends analysis_templatesUpdateManyAndReturnArgs>(args: SelectSubset<T, analysis_templatesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Analysis_templates.
     * @param {analysis_templatesUpsertArgs} args - Arguments to update or create a Analysis_templates.
     * @example
     * // Update or create a Analysis_templates
     * const analysis_templates = await prisma.analysis_templates.upsert({
     *   create: {
     *     // ... data to create a Analysis_templates
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Analysis_templates we want to update
     *   }
     * })
     */
    upsert<T extends analysis_templatesUpsertArgs>(args: SelectSubset<T, analysis_templatesUpsertArgs<ExtArgs>>): Prisma__analysis_templatesClient<$Result.GetResult<Prisma.$analysis_templatesPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Analysis_templates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysis_templatesCountArgs} args - Arguments to filter Analysis_templates to count.
     * @example
     * // Count the number of Analysis_templates
     * const count = await prisma.analysis_templates.count({
     *   where: {
     *     // ... the filter for the Analysis_templates we want to count
     *   }
     * })
    **/
    count<T extends analysis_templatesCountArgs>(
      args?: Subset<T, analysis_templatesCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Analysis_templatesCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Analysis_templates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Analysis_templatesAggregateArgs} 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 Analysis_templatesAggregateArgs>(args: Subset<T, Analysis_templatesAggregateArgs>): Prisma.PrismaPromise<GetAnalysis_templatesAggregateType<T>>

    /**
     * Group by Analysis_templates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {analysis_templatesGroupByArgs} 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 analysis_templatesGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: analysis_templatesGroupByArgs['orderBy'] }
        : { orderBy?: analysis_templatesGroupByArgs['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, analysis_templatesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAnalysis_templatesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the analysis_templates model
   */
  readonly fields: analysis_templatesFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for analysis_templates.
   * 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__analysis_templatesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the analysis_templates model
   */
  interface analysis_templatesFieldRefs {
    readonly id: FieldRef<"analysis_templates", 'String'>
    readonly name: FieldRef<"analysis_templates", 'String'>
    readonly description: FieldRef<"analysis_templates", 'String'>
    readonly config: FieldRef<"analysis_templates", 'Json'>
    readonly user_id: FieldRef<"analysis_templates", 'String'>
    readonly is_public: FieldRef<"analysis_templates", 'Boolean'>
    readonly created_at: FieldRef<"analysis_templates", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * analysis_templates findUnique
   */
  export type analysis_templatesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter, which analysis_templates to fetch.
     */
    where: analysis_templatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates findUniqueOrThrow
   */
  export type analysis_templatesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter, which analysis_templates to fetch.
     */
    where: analysis_templatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates findFirst
   */
  export type analysis_templatesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter, which analysis_templates to fetch.
     */
    where?: analysis_templatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analysis_templates to fetch.
     */
    orderBy?: analysis_templatesOrderByWithRelationInput | analysis_templatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for analysis_templates.
     */
    cursor?: analysis_templatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analysis_templates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analysis_templates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of analysis_templates.
     */
    distinct?: Analysis_templatesScalarFieldEnum | Analysis_templatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates findFirstOrThrow
   */
  export type analysis_templatesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter, which analysis_templates to fetch.
     */
    where?: analysis_templatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analysis_templates to fetch.
     */
    orderBy?: analysis_templatesOrderByWithRelationInput | analysis_templatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for analysis_templates.
     */
    cursor?: analysis_templatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analysis_templates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analysis_templates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of analysis_templates.
     */
    distinct?: Analysis_templatesScalarFieldEnum | Analysis_templatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates findMany
   */
  export type analysis_templatesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter, which analysis_templates to fetch.
     */
    where?: analysis_templatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of analysis_templates to fetch.
     */
    orderBy?: analysis_templatesOrderByWithRelationInput | analysis_templatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing analysis_templates.
     */
    cursor?: analysis_templatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` analysis_templates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` analysis_templates.
     */
    skip?: number
    distinct?: Analysis_templatesScalarFieldEnum | Analysis_templatesScalarFieldEnum[]
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates create
   */
  export type analysis_templatesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * The data needed to create a analysis_templates.
     */
    data: XOR<analysis_templatesCreateInput, analysis_templatesUncheckedCreateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates createMany
   */
  export type analysis_templatesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many analysis_templates.
     */
    data: analysis_templatesCreateManyInput | analysis_templatesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * analysis_templates createManyAndReturn
   */
  export type analysis_templatesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * The data used to create many analysis_templates.
     */
    data: analysis_templatesCreateManyInput | analysis_templatesCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * analysis_templates update
   */
  export type analysis_templatesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * The data needed to update a analysis_templates.
     */
    data: XOR<analysis_templatesUpdateInput, analysis_templatesUncheckedUpdateInput>
    /**
     * Choose, which analysis_templates to update.
     */
    where: analysis_templatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates updateMany
   */
  export type analysis_templatesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update analysis_templates.
     */
    data: XOR<analysis_templatesUpdateManyMutationInput, analysis_templatesUncheckedUpdateManyInput>
    /**
     * Filter which analysis_templates to update
     */
    where?: analysis_templatesWhereInput
    /**
     * Limit how many analysis_templates to update.
     */
    limit?: number
  }

  /**
   * analysis_templates updateManyAndReturn
   */
  export type analysis_templatesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * The data used to update analysis_templates.
     */
    data: XOR<analysis_templatesUpdateManyMutationInput, analysis_templatesUncheckedUpdateManyInput>
    /**
     * Filter which analysis_templates to update
     */
    where?: analysis_templatesWhereInput
    /**
     * Limit how many analysis_templates to update.
     */
    limit?: number
  }

  /**
   * analysis_templates upsert
   */
  export type analysis_templatesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * The filter to search for the analysis_templates to update in case it exists.
     */
    where: analysis_templatesWhereUniqueInput
    /**
     * In case the analysis_templates found by the `where` argument doesn't exist, create a new analysis_templates with this data.
     */
    create: XOR<analysis_templatesCreateInput, analysis_templatesUncheckedCreateInput>
    /**
     * In case the analysis_templates was found with the provided `where` argument, update it with this data.
     */
    update: XOR<analysis_templatesUpdateInput, analysis_templatesUncheckedUpdateInput>
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates delete
   */
  export type analysis_templatesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
    /**
     * Filter which analysis_templates to delete.
     */
    where: analysis_templatesWhereUniqueInput
    relationLoadStrategy?: RelationLoadStrategy
  }

  /**
   * analysis_templates deleteMany
   */
  export type analysis_templatesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which analysis_templates to delete
     */
    where?: analysis_templatesWhereInput
    /**
     * Limit how many analysis_templates to delete.
     */
    limit?: number
  }

  /**
   * analysis_templates without action
   */
  export type analysis_templatesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the analysis_templates
     */
    select?: analysis_templatesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the analysis_templates
     */
    omit?: analysis_templatesOmit<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const ProfilesScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    avatar: 'avatar',
    username: 'username',
    first_name: 'first_name',
    last_name: 'last_name',
    bio: 'bio',
    address: 'address',
    birth_date: 'birth_date',
    nik: 'nik',
    birth_place: 'birth_place'
  };

  export type ProfilesScalarFieldEnum = (typeof ProfilesScalarFieldEnum)[keyof typeof ProfilesScalarFieldEnum]


  export const RelationLoadStrategy: {
    query: 'query',
    join: 'join'
  };

  export type RelationLoadStrategy = (typeof RelationLoadStrategy)[keyof typeof RelationLoadStrategy]


  export const UsersScalarFieldEnum: {
    id: 'id',
    roles_id: 'roles_id',
    email: 'email',
    phone: 'phone',
    encrypted_password: 'encrypted_password',
    invited_at: 'invited_at',
    confirmed_at: 'confirmed_at',
    email_confirmed_at: 'email_confirmed_at',
    recovery_sent_at: 'recovery_sent_at',
    last_sign_in_at: 'last_sign_in_at',
    app_metadata: 'app_metadata',
    user_metadata: 'user_metadata',
    created_at: 'created_at',
    updated_at: 'updated_at',
    banned_until: 'banned_until',
    is_anonymous: 'is_anonymous',
    banned_reason: 'banned_reason',
    is_banned: 'is_banned',
    panic_strike: 'panic_strike',
    spoofing_attempts: 'spoofing_attempts'
  };

  export type UsersScalarFieldEnum = (typeof UsersScalarFieldEnum)[keyof typeof UsersScalarFieldEnum]


  export const RolesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type RolesScalarFieldEnum = (typeof RolesScalarFieldEnum)[keyof typeof RolesScalarFieldEnum]


  export const SessionsScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    event_id: 'event_id',
    status: 'status',
    created_at: 'created_at'
  };

  export type SessionsScalarFieldEnum = (typeof SessionsScalarFieldEnum)[keyof typeof SessionsScalarFieldEnum]


  export const EventsScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    code: 'code',
    created_at: 'created_at',
    user_id: 'user_id'
  };

  export type EventsScalarFieldEnum = (typeof EventsScalarFieldEnum)[keyof typeof EventsScalarFieldEnum]


  export const ResourcesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    type: 'type',
    description: 'description',
    instance_role: 'instance_role',
    relations: 'relations',
    attributes: 'attributes',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ResourcesScalarFieldEnum = (typeof ResourcesScalarFieldEnum)[keyof typeof ResourcesScalarFieldEnum]


  export const PermissionsScalarFieldEnum: {
    id: 'id',
    action: 'action',
    resource_id: 'resource_id',
    role_id: 'role_id',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type PermissionsScalarFieldEnum = (typeof PermissionsScalarFieldEnum)[keyof typeof PermissionsScalarFieldEnum]


  export const CitiesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type CitiesScalarFieldEnum = (typeof CitiesScalarFieldEnum)[keyof typeof CitiesScalarFieldEnum]


  export const Crime_incidentsScalarFieldEnum: {
    id: 'id',
    crime_id: 'crime_id',
    crime_category_id: 'crime_category_id',
    location_id: 'location_id',
    description: 'description',
    victim_count: 'victim_count',
    status: 'status',
    created_at: 'created_at',
    updated_at: 'updated_at',
    timestamp: 'timestamp'
  };

  export type Crime_incidentsScalarFieldEnum = (typeof Crime_incidentsScalarFieldEnum)[keyof typeof Crime_incidentsScalarFieldEnum]


  export const Crime_categoriesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    created_at: 'created_at',
    updated_at: 'updated_at',
    type: 'type'
  };

  export type Crime_categoriesScalarFieldEnum = (typeof Crime_categoriesScalarFieldEnum)[keyof typeof Crime_categoriesScalarFieldEnum]


  export const CrimesScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    created_at: 'created_at',
    level: 'level',
    method: 'method',
    month: 'month',
    number_of_crime: 'number_of_crime',
    score: 'score',
    updated_at: 'updated_at',
    year: 'year',
    source_type: 'source_type',
    crime_cleared: 'crime_cleared',
    avg_crime: 'avg_crime'
  };

  export type CrimesScalarFieldEnum = (typeof CrimesScalarFieldEnum)[keyof typeof CrimesScalarFieldEnum]


  export const DemographicsScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    population: 'population',
    number_of_unemployed: 'number_of_unemployed',
    population_density: 'population_density',
    year: 'year',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type DemographicsScalarFieldEnum = (typeof DemographicsScalarFieldEnum)[keyof typeof DemographicsScalarFieldEnum]


  export const DistrictsScalarFieldEnum: {
    id: 'id',
    city_id: 'city_id',
    name: 'name',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type DistrictsScalarFieldEnum = (typeof DistrictsScalarFieldEnum)[keyof typeof DistrictsScalarFieldEnum]


  export const LocationsScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    event_id: 'event_id',
    address: 'address',
    type: 'type',
    latitude: 'latitude',
    longitude: 'longitude',
    land_area: 'land_area',
    created_at: 'created_at',
    updated_at: 'updated_at',
    distance_to_unit: 'distance_to_unit'
  };

  export type LocationsScalarFieldEnum = (typeof LocationsScalarFieldEnum)[keyof typeof LocationsScalarFieldEnum]


  export const Incident_logsScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    location_id: 'location_id',
    category_id: 'category_id',
    description: 'description',
    source: 'source',
    time: 'time',
    verified: 'verified',
    severity: 'severity',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type Incident_logsScalarFieldEnum = (typeof Incident_logsScalarFieldEnum)[keyof typeof Incident_logsScalarFieldEnum]


  export const TimelinesScalarFieldEnum: {
    id: 'id',
    incident_logs_id: 'incident_logs_id',
    crime_incidents_id: 'crime_incidents_id',
    user_id: 'user_id',
    title: 'title',
    description: 'description',
    timestamp: 'timestamp',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type TimelinesScalarFieldEnum = (typeof TimelinesScalarFieldEnum)[keyof typeof TimelinesScalarFieldEnum]


  export const WitnessesScalarFieldEnum: {
    id: 'id',
    incident_logs_id: 'incident_logs_id',
    crime_incidents_id: 'crime_incidents_id',
    name: 'name',
    contact_info: 'contact_info',
    statement: 'statement',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type WitnessesScalarFieldEnum = (typeof WitnessesScalarFieldEnum)[keyof typeof WitnessesScalarFieldEnum]


  export const EvidenceScalarFieldEnum: {
    incident_logs_id: 'incident_logs_id',
    crime_incidents_id: 'crime_incidents_id',
    type: 'type',
    url: 'url',
    status: 'status',
    uploaded_at: 'uploaded_at',
    updated_at: 'updated_at',
    caption: 'caption',
    description: 'description',
    metadata: 'metadata',
    id: 'id'
  };

  export type EvidenceScalarFieldEnum = (typeof EvidenceScalarFieldEnum)[keyof typeof EvidenceScalarFieldEnum]


  export const UnitsScalarFieldEnum: {
    code_unit: 'code_unit',
    district_id: 'district_id',
    name: 'name',
    description: 'description',
    type: 'type',
    created_at: 'created_at',
    updated_at: 'updated_at',
    address: 'address',
    land_area: 'land_area',
    latitude: 'latitude',
    longitude: 'longitude',
    city_id: 'city_id',
    phone: 'phone'
  };

  export type UnitsScalarFieldEnum = (typeof UnitsScalarFieldEnum)[keyof typeof UnitsScalarFieldEnum]


  export const Patrol_unitsScalarFieldEnum: {
    unit_id: 'unit_id',
    location_id: 'location_id',
    name: 'name',
    type: 'type',
    status: 'status',
    radius: 'radius',
    created_at: 'created_at',
    id: 'id',
    category: 'category',
    member_count: 'member_count',
    updated_at: 'updated_at'
  };

  export type Patrol_unitsScalarFieldEnum = (typeof Patrol_unitsScalarFieldEnum)[keyof typeof Patrol_unitsScalarFieldEnum]


  export const OfficersScalarFieldEnum: {
    unit_id: 'unit_id',
    role_id: 'role_id',
    nrp: 'nrp',
    name: 'name',
    rank: 'rank',
    position: 'position',
    phone: 'phone',
    email: 'email',
    avatar: 'avatar',
    valid_until: 'valid_until',
    qr_code: 'qr_code',
    created_at: 'created_at',
    updated_at: 'updated_at',
    patrol_unit_id: 'patrol_unit_id',
    id: 'id',
    banned_reason: 'banned_reason',
    banned_until: 'banned_until',
    is_banned: 'is_banned',
    panic_strike: 'panic_strike',
    spoofing_attempts: 'spoofing_attempts',
    place_of_birth: 'place_of_birth',
    date_of_birth: 'date_of_birth'
  };

  export type OfficersScalarFieldEnum = (typeof OfficersScalarFieldEnum)[keyof typeof OfficersScalarFieldEnum]


  export const Unit_statisticsScalarFieldEnum: {
    id: 'id',
    crime_total: 'crime_total',
    crime_cleared: 'crime_cleared',
    percentage: 'percentage',
    pending: 'pending',
    month: 'month',
    year: 'year',
    created_at: 'created_at',
    updated_at: 'updated_at',
    code_unit: 'code_unit'
  };

  export type Unit_statisticsScalarFieldEnum = (typeof Unit_statisticsScalarFieldEnum)[keyof typeof Unit_statisticsScalarFieldEnum]


  export const GeographicsScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    address: 'address',
    longitude: 'longitude',
    latitude: 'latitude',
    land_area: 'land_area',
    created_at: 'created_at',
    updated_at: 'updated_at',
    description: 'description',
    type: 'type',
    year: 'year'
  };

  export type GeographicsScalarFieldEnum = (typeof GeographicsScalarFieldEnum)[keyof typeof GeographicsScalarFieldEnum]


  export const Contact_messagesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    email: 'email',
    phone: 'phone',
    message_type: 'message_type',
    message_type_label: 'message_type_label',
    message: 'message',
    status: 'status',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type Contact_messagesScalarFieldEnum = (typeof Contact_messagesScalarFieldEnum)[keyof typeof Contact_messagesScalarFieldEnum]


  export const MessagesScalarFieldEnum: {
    id: 'id',
    subject: 'subject',
    content: 'content',
    message_type: 'message_type',
    message_type_label: 'message_type_label',
    sender_user_id: 'sender_user_id',
    sender_officer_id: 'sender_officer_id',
    recipient_user_id: 'recipient_user_id',
    recipient_officer_id: 'recipient_officer_id',
    inbox_id: 'inbox_id',
    status: 'status',
    created_at: 'created_at',
    updated_at: 'updated_at',
    file_url: 'file_url',
    file_type: 'file_type',
    file_name: 'file_name',
    is_starred: 'is_starred'
  };

  export type MessagesScalarFieldEnum = (typeof MessagesScalarFieldEnum)[keyof typeof MessagesScalarFieldEnum]


  export const InboxScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    officer_id: 'officer_id',
    unread_count: 'unread_count',
    last_updated: 'last_updated',
    created_at: 'created_at'
  };

  export type InboxScalarFieldEnum = (typeof InboxScalarFieldEnum)[keyof typeof InboxScalarFieldEnum]


  export const LogsScalarFieldEnum: {
    id: 'id',
    action: 'action',
    entity: 'entity',
    entity_id: 'entity_id',
    changes: 'changes',
    user_id: 'user_id',
    ip_address: 'ip_address',
    user_agent: 'user_agent',
    created_at: 'created_at'
  };

  export type LogsScalarFieldEnum = (typeof LogsScalarFieldEnum)[keyof typeof LogsScalarFieldEnum]


  export const Panic_button_logsScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    officer_id: 'officer_id',
    incident_logs_id: 'incident_logs_id',
    timestamp: 'timestamp'
  };

  export type Panic_button_logsScalarFieldEnum = (typeof Panic_button_logsScalarFieldEnum)[keyof typeof Panic_button_logsScalarFieldEnum]


  export const Location_logsScalarFieldEnum: {
    id: 'id',
    location_id: 'location_id',
    latitude: 'latitude',
    longitude: 'longitude',
    timestamp: 'timestamp',
    description: 'description',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type Location_logsScalarFieldEnum = (typeof Location_logsScalarFieldEnum)[keyof typeof Location_logsScalarFieldEnum]


  export const District_clustersScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    year: 'year',
    month: 'month',
    risk_level: 'risk_level',
    total_crimes: 'total_crimes',
    population_density: 'population_density',
    unemployment_rate: 'unemployment_rate',
    crime_score: 'crime_score',
    density_score: 'density_score',
    unemployment_score: 'unemployment_score',
    cluster_score: 'cluster_score',
    centroid_features: 'centroid_features',
    member_count: 'member_count',
    last_update_type: 'last_update_type',
    update_count: 'update_count',
    needs_recompute: 'needs_recompute',
    incidents_data: 'incidents_data',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type District_clustersScalarFieldEnum = (typeof District_clustersScalarFieldEnum)[keyof typeof District_clustersScalarFieldEnum]


  export const Cluster_updatesScalarFieldEnum: {
    id: 'id',
    district_id: 'district_id',
    update_type: 'update_type',
    old_value: 'old_value',
    new_value: 'new_value',
    processed: 'processed',
    timestamp: 'timestamp'
  };

  export type Cluster_updatesScalarFieldEnum = (typeof Cluster_updatesScalarFieldEnum)[keyof typeof Cluster_updatesScalarFieldEnum]


  export const TaskScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    code: 'code',
    title: 'title',
    status: 'status',
    label: 'label',
    priority: 'priority',
    estimated_hours: 'estimated_hours',
    archived: 'archived',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type TaskScalarFieldEnum = (typeof TaskScalarFieldEnum)[keyof typeof TaskScalarFieldEnum]


  export const ProjectsScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    user_id: 'user_id',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ProjectsScalarFieldEnum = (typeof ProjectsScalarFieldEnum)[keyof typeof ProjectsScalarFieldEnum]


  export const DatasetsScalarFieldEnum: {
    id: 'id',
    project_id: 'project_id',
    filename: 'filename',
    original_name: 'original_name',
    file_size: 'file_size',
    columns: 'columns',
    row_count: 'row_count',
    metadata: 'metadata',
    created_at: 'created_at'
  };

  export type DatasetsScalarFieldEnum = (typeof DatasetsScalarFieldEnum)[keyof typeof DatasetsScalarFieldEnum]


  export const AnalysesScalarFieldEnum: {
    id: 'id',
    project_id: 'project_id',
    dataset_id: 'dataset_id',
    name: 'name',
    config: 'config',
    results: 'results',
    status: 'status',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type AnalysesScalarFieldEnum = (typeof AnalysesScalarFieldEnum)[keyof typeof AnalysesScalarFieldEnum]


  export const ClustersScalarFieldEnum: {
    id: 'id',
    analysis_id: 'analysis_id',
    cluster_id: 'cluster_id',
    center_data: 'center_data',
    point_count: 'point_count',
    characteristics: 'characteristics'
  };

  export type ClustersScalarFieldEnum = (typeof ClustersScalarFieldEnum)[keyof typeof ClustersScalarFieldEnum]


  export const Analysis_templatesScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    config: 'config',
    user_id: 'user_id',
    is_public: 'is_public',
    created_at: 'created_at'
  };

  export type Analysis_templatesScalarFieldEnum = (typeof Analysis_templatesScalarFieldEnum)[keyof typeof Analysis_templatesScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const NullableJsonNullValueInput: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull
  };

  export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]


  export const JsonNullValueInput: {
    JsonNull: typeof JsonNull
  };

  export type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput]


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

  export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

  export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  /**
   * Field references
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'String[]'
   */
  export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'QueryMode'
   */
  export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type '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 'session_status'
   */
  export type Enumsession_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'session_status'>
    


  /**
   * Reference to a field of type 'session_status[]'
   */
  export type ListEnumsession_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'session_status[]'>
    


  /**
   * Reference to a field of type 'crime_status'
   */
  export type Enumcrime_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'crime_status'>
    


  /**
   * Reference to a field of type 'crime_status[]'
   */
  export type ListEnumcrime_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'crime_status[]'>
    


  /**
   * Reference to a field of type 'crime_rates'
   */
  export type Enumcrime_ratesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'crime_rates'>
    


  /**
   * Reference to a field of type 'crime_rates[]'
   */
  export type ListEnumcrime_ratesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'crime_rates[]'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    


  /**
   * Reference to a field of type 'unit_type'
   */
  export type Enumunit_typeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'unit_type'>
    


  /**
   * Reference to a field of type 'unit_type[]'
   */
  export type ListEnumunit_typeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'unit_type[]'>
    


  /**
   * Reference to a field of type 'patrol_unit_category'
   */
  export type Enumpatrol_unit_categoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'patrol_unit_category'>
    


  /**
   * Reference to a field of type 'patrol_unit_category[]'
   */
  export type ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'patrol_unit_category[]'>
    


  /**
   * Reference to a field of type 'status_messages'
   */
  export type Enumstatus_messagesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'status_messages'>
    


  /**
   * Reference to a field of type 'status_messages[]'
   */
  export type ListEnumstatus_messagesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'status_messages[]'>
    


  /**
   * Reference to a field of type 'task_status'
   */
  export type Enumtask_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_status'>
    


  /**
   * Reference to a field of type 'task_status[]'
   */
  export type ListEnumtask_statusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_status[]'>
    


  /**
   * Reference to a field of type 'task_label'
   */
  export type Enumtask_labelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_label'>
    


  /**
   * Reference to a field of type 'task_label[]'
   */
  export type ListEnumtask_labelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_label[]'>
    


  /**
   * Reference to a field of type 'task_priority'
   */
  export type Enumtask_priorityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_priority'>
    


  /**
   * Reference to a field of type 'task_priority[]'
   */
  export type ListEnumtask_priorityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'task_priority[]'>
    
  /**
   * Deep Input Types
   */


  export type profilesWhereInput = {
    AND?: profilesWhereInput | profilesWhereInput[]
    OR?: profilesWhereInput[]
    NOT?: profilesWhereInput | profilesWhereInput[]
    id?: UuidFilter<"profiles"> | string
    user_id?: UuidFilter<"profiles"> | string
    avatar?: StringNullableFilter<"profiles"> | string | null
    username?: StringNullableFilter<"profiles"> | string | null
    first_name?: StringNullableFilter<"profiles"> | string | null
    last_name?: StringNullableFilter<"profiles"> | string | null
    bio?: StringNullableFilter<"profiles"> | string | null
    address?: JsonNullableFilter<"profiles">
    birth_date?: DateTimeNullableFilter<"profiles"> | Date | string | null
    nik?: StringNullableFilter<"profiles"> | string | null
    birth_place?: StringNullableFilter<"profiles"> | string | null
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }

  export type profilesOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    avatar?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    first_name?: SortOrderInput | SortOrder
    last_name?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    birth_date?: SortOrderInput | SortOrder
    nik?: SortOrderInput | SortOrder
    birth_place?: SortOrderInput | SortOrder
    users?: usersOrderByWithRelationInput
  }

  export type profilesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    user_id?: string
    username?: string
    AND?: profilesWhereInput | profilesWhereInput[]
    OR?: profilesWhereInput[]
    NOT?: profilesWhereInput | profilesWhereInput[]
    avatar?: StringNullableFilter<"profiles"> | string | null
    first_name?: StringNullableFilter<"profiles"> | string | null
    last_name?: StringNullableFilter<"profiles"> | string | null
    bio?: StringNullableFilter<"profiles"> | string | null
    address?: JsonNullableFilter<"profiles">
    birth_date?: DateTimeNullableFilter<"profiles"> | Date | string | null
    nik?: StringNullableFilter<"profiles"> | string | null
    birth_place?: StringNullableFilter<"profiles"> | string | null
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }, "id" | "user_id" | "username">

  export type profilesOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    avatar?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    first_name?: SortOrderInput | SortOrder
    last_name?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    birth_date?: SortOrderInput | SortOrder
    nik?: SortOrderInput | SortOrder
    birth_place?: SortOrderInput | SortOrder
    _count?: profilesCountOrderByAggregateInput
    _max?: profilesMaxOrderByAggregateInput
    _min?: profilesMinOrderByAggregateInput
  }

  export type profilesScalarWhereWithAggregatesInput = {
    AND?: profilesScalarWhereWithAggregatesInput | profilesScalarWhereWithAggregatesInput[]
    OR?: profilesScalarWhereWithAggregatesInput[]
    NOT?: profilesScalarWhereWithAggregatesInput | profilesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"profiles"> | string
    user_id?: UuidWithAggregatesFilter<"profiles"> | string
    avatar?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    username?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    first_name?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    last_name?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    bio?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    address?: JsonNullableWithAggregatesFilter<"profiles">
    birth_date?: DateTimeNullableWithAggregatesFilter<"profiles"> | Date | string | null
    nik?: StringNullableWithAggregatesFilter<"profiles"> | string | null
    birth_place?: StringNullableWithAggregatesFilter<"profiles"> | string | null
  }

  export type usersWhereInput = {
    AND?: usersWhereInput | usersWhereInput[]
    OR?: usersWhereInput[]
    NOT?: usersWhereInput | usersWhereInput[]
    id?: UuidFilter<"users"> | string
    roles_id?: UuidFilter<"users"> | string
    email?: StringFilter<"users"> | string
    phone?: StringNullableFilter<"users"> | string | null
    encrypted_password?: StringNullableFilter<"users"> | string | null
    invited_at?: DateTimeNullableFilter<"users"> | Date | string | null
    confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    email_confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    recovery_sent_at?: DateTimeNullableFilter<"users"> | Date | string | null
    last_sign_in_at?: DateTimeNullableFilter<"users"> | Date | string | null
    app_metadata?: JsonNullableFilter<"users">
    user_metadata?: JsonNullableFilter<"users">
    created_at?: DateTimeFilter<"users"> | Date | string
    updated_at?: DateTimeFilter<"users"> | Date | string
    banned_until?: DateTimeNullableFilter<"users"> | Date | string | null
    is_anonymous?: BoolFilter<"users"> | boolean
    banned_reason?: StringNullableFilter<"users"> | string | null
    is_banned?: BoolFilter<"users"> | boolean
    panic_strike?: IntFilter<"users"> | number
    spoofing_attempts?: IntFilter<"users"> | number
    events?: EventsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
    panic_button_logs?: Panic_button_logsListRelationFilter
    profile?: XOR<ProfilesNullableScalarRelationFilter, profilesWhereInput> | null
    sessions?: SessionsListRelationFilter
    timelines?: TimelinesListRelationFilter
    role?: XOR<RolesScalarRelationFilter, rolesWhereInput>
    task?: TaskListRelationFilter
    sentMessages?: MessagesListRelationFilter
    receivedMessages?: MessagesListRelationFilter
    projects?: ProjectsListRelationFilter
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }

  export type usersOrderByWithRelationInput = {
    id?: SortOrder
    roles_id?: SortOrder
    email?: SortOrder
    phone?: SortOrderInput | SortOrder
    encrypted_password?: SortOrderInput | SortOrder
    invited_at?: SortOrderInput | SortOrder
    confirmed_at?: SortOrderInput | SortOrder
    email_confirmed_at?: SortOrderInput | SortOrder
    recovery_sent_at?: SortOrderInput | SortOrder
    last_sign_in_at?: SortOrderInput | SortOrder
    app_metadata?: SortOrderInput | SortOrder
    user_metadata?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    banned_until?: SortOrderInput | SortOrder
    is_anonymous?: SortOrder
    banned_reason?: SortOrderInput | SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    events?: eventsOrderByRelationAggregateInput
    incident_logs?: incident_logsOrderByRelationAggregateInput
    panic_button_logs?: panic_button_logsOrderByRelationAggregateInput
    profile?: profilesOrderByWithRelationInput
    sessions?: sessionsOrderByRelationAggregateInput
    timelines?: timelinesOrderByRelationAggregateInput
    role?: rolesOrderByWithRelationInput
    task?: taskOrderByRelationAggregateInput
    sentMessages?: messagesOrderByRelationAggregateInput
    receivedMessages?: messagesOrderByRelationAggregateInput
    projects?: projectsOrderByRelationAggregateInput
    inbox?: inboxOrderByWithRelationInput
  }

  export type usersWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    phone?: string
    AND?: usersWhereInput | usersWhereInput[]
    OR?: usersWhereInput[]
    NOT?: usersWhereInput | usersWhereInput[]
    roles_id?: UuidFilter<"users"> | string
    encrypted_password?: StringNullableFilter<"users"> | string | null
    invited_at?: DateTimeNullableFilter<"users"> | Date | string | null
    confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    email_confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    recovery_sent_at?: DateTimeNullableFilter<"users"> | Date | string | null
    last_sign_in_at?: DateTimeNullableFilter<"users"> | Date | string | null
    app_metadata?: JsonNullableFilter<"users">
    user_metadata?: JsonNullableFilter<"users">
    created_at?: DateTimeFilter<"users"> | Date | string
    updated_at?: DateTimeFilter<"users"> | Date | string
    banned_until?: DateTimeNullableFilter<"users"> | Date | string | null
    is_anonymous?: BoolFilter<"users"> | boolean
    banned_reason?: StringNullableFilter<"users"> | string | null
    is_banned?: BoolFilter<"users"> | boolean
    panic_strike?: IntFilter<"users"> | number
    spoofing_attempts?: IntFilter<"users"> | number
    events?: EventsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
    panic_button_logs?: Panic_button_logsListRelationFilter
    profile?: XOR<ProfilesNullableScalarRelationFilter, profilesWhereInput> | null
    sessions?: SessionsListRelationFilter
    timelines?: TimelinesListRelationFilter
    role?: XOR<RolesScalarRelationFilter, rolesWhereInput>
    task?: TaskListRelationFilter
    sentMessages?: MessagesListRelationFilter
    receivedMessages?: MessagesListRelationFilter
    projects?: ProjectsListRelationFilter
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }, "id" | "email" | "phone">

  export type usersOrderByWithAggregationInput = {
    id?: SortOrder
    roles_id?: SortOrder
    email?: SortOrder
    phone?: SortOrderInput | SortOrder
    encrypted_password?: SortOrderInput | SortOrder
    invited_at?: SortOrderInput | SortOrder
    confirmed_at?: SortOrderInput | SortOrder
    email_confirmed_at?: SortOrderInput | SortOrder
    recovery_sent_at?: SortOrderInput | SortOrder
    last_sign_in_at?: SortOrderInput | SortOrder
    app_metadata?: SortOrderInput | SortOrder
    user_metadata?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    banned_until?: SortOrderInput | SortOrder
    is_anonymous?: SortOrder
    banned_reason?: SortOrderInput | SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    _count?: usersCountOrderByAggregateInput
    _avg?: usersAvgOrderByAggregateInput
    _max?: usersMaxOrderByAggregateInput
    _min?: usersMinOrderByAggregateInput
    _sum?: usersSumOrderByAggregateInput
  }

  export type usersScalarWhereWithAggregatesInput = {
    AND?: usersScalarWhereWithAggregatesInput | usersScalarWhereWithAggregatesInput[]
    OR?: usersScalarWhereWithAggregatesInput[]
    NOT?: usersScalarWhereWithAggregatesInput | usersScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"users"> | string
    roles_id?: UuidWithAggregatesFilter<"users"> | string
    email?: StringWithAggregatesFilter<"users"> | string
    phone?: StringNullableWithAggregatesFilter<"users"> | string | null
    encrypted_password?: StringNullableWithAggregatesFilter<"users"> | string | null
    invited_at?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    confirmed_at?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    email_confirmed_at?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    recovery_sent_at?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    last_sign_in_at?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    app_metadata?: JsonNullableWithAggregatesFilter<"users">
    user_metadata?: JsonNullableWithAggregatesFilter<"users">
    created_at?: DateTimeWithAggregatesFilter<"users"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"users"> | Date | string
    banned_until?: DateTimeNullableWithAggregatesFilter<"users"> | Date | string | null
    is_anonymous?: BoolWithAggregatesFilter<"users"> | boolean
    banned_reason?: StringNullableWithAggregatesFilter<"users"> | string | null
    is_banned?: BoolWithAggregatesFilter<"users"> | boolean
    panic_strike?: IntWithAggregatesFilter<"users"> | number
    spoofing_attempts?: IntWithAggregatesFilter<"users"> | number
  }

  export type rolesWhereInput = {
    AND?: rolesWhereInput | rolesWhereInput[]
    OR?: rolesWhereInput[]
    NOT?: rolesWhereInput | rolesWhereInput[]
    id?: UuidFilter<"roles"> | string
    name?: StringFilter<"roles"> | string
    description?: StringNullableFilter<"roles"> | string | null
    created_at?: DateTimeFilter<"roles"> | Date | string
    updated_at?: DateTimeFilter<"roles"> | Date | string
    officers?: OfficersListRelationFilter
    permissions?: PermissionsListRelationFilter
    users?: UsersListRelationFilter
  }

  export type rolesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    officers?: officersOrderByRelationAggregateInput
    permissions?: permissionsOrderByRelationAggregateInput
    users?: usersOrderByRelationAggregateInput
  }

  export type rolesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    AND?: rolesWhereInput | rolesWhereInput[]
    OR?: rolesWhereInput[]
    NOT?: rolesWhereInput | rolesWhereInput[]
    description?: StringNullableFilter<"roles"> | string | null
    created_at?: DateTimeFilter<"roles"> | Date | string
    updated_at?: DateTimeFilter<"roles"> | Date | string
    officers?: OfficersListRelationFilter
    permissions?: PermissionsListRelationFilter
    users?: UsersListRelationFilter
  }, "id" | "name">

  export type rolesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: rolesCountOrderByAggregateInput
    _max?: rolesMaxOrderByAggregateInput
    _min?: rolesMinOrderByAggregateInput
  }

  export type rolesScalarWhereWithAggregatesInput = {
    AND?: rolesScalarWhereWithAggregatesInput | rolesScalarWhereWithAggregatesInput[]
    OR?: rolesScalarWhereWithAggregatesInput[]
    NOT?: rolesScalarWhereWithAggregatesInput | rolesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"roles"> | string
    name?: StringWithAggregatesFilter<"roles"> | string
    description?: StringNullableWithAggregatesFilter<"roles"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"roles"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"roles"> | Date | string
  }

  export type sessionsWhereInput = {
    AND?: sessionsWhereInput | sessionsWhereInput[]
    OR?: sessionsWhereInput[]
    NOT?: sessionsWhereInput | sessionsWhereInput[]
    id?: UuidFilter<"sessions"> | string
    user_id?: UuidFilter<"sessions"> | string
    event_id?: UuidFilter<"sessions"> | string
    status?: Enumsession_statusFilter<"sessions"> | $Enums.session_status
    created_at?: DateTimeFilter<"sessions"> | Date | string
    event?: XOR<EventsScalarRelationFilter, eventsWhereInput>
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }

  export type sessionsOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    event_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    event?: eventsOrderByWithRelationInput
    user?: usersOrderByWithRelationInput
  }

  export type sessionsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: sessionsWhereInput | sessionsWhereInput[]
    OR?: sessionsWhereInput[]
    NOT?: sessionsWhereInput | sessionsWhereInput[]
    user_id?: UuidFilter<"sessions"> | string
    event_id?: UuidFilter<"sessions"> | string
    status?: Enumsession_statusFilter<"sessions"> | $Enums.session_status
    created_at?: DateTimeFilter<"sessions"> | Date | string
    event?: XOR<EventsScalarRelationFilter, eventsWhereInput>
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }, "id">

  export type sessionsOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    event_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    _count?: sessionsCountOrderByAggregateInput
    _max?: sessionsMaxOrderByAggregateInput
    _min?: sessionsMinOrderByAggregateInput
  }

  export type sessionsScalarWhereWithAggregatesInput = {
    AND?: sessionsScalarWhereWithAggregatesInput | sessionsScalarWhereWithAggregatesInput[]
    OR?: sessionsScalarWhereWithAggregatesInput[]
    NOT?: sessionsScalarWhereWithAggregatesInput | sessionsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"sessions"> | string
    user_id?: UuidWithAggregatesFilter<"sessions"> | string
    event_id?: UuidWithAggregatesFilter<"sessions"> | string
    status?: Enumsession_statusWithAggregatesFilter<"sessions"> | $Enums.session_status
    created_at?: DateTimeWithAggregatesFilter<"sessions"> | Date | string
  }

  export type eventsWhereInput = {
    AND?: eventsWhereInput | eventsWhereInput[]
    OR?: eventsWhereInput[]
    NOT?: eventsWhereInput | eventsWhereInput[]
    id?: UuidFilter<"events"> | string
    name?: StringFilter<"events"> | string
    description?: StringNullableFilter<"events"> | string | null
    code?: StringFilter<"events"> | string
    created_at?: DateTimeFilter<"events"> | Date | string
    user_id?: UuidFilter<"events"> | string
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
    locations?: LocationsListRelationFilter
    sessions?: SessionsListRelationFilter
  }

  export type eventsOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    code?: SortOrder
    created_at?: SortOrder
    user_id?: SortOrder
    users?: usersOrderByWithRelationInput
    locations?: locationsOrderByRelationAggregateInput
    sessions?: sessionsOrderByRelationAggregateInput
  }

  export type eventsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    code?: string
    AND?: eventsWhereInput | eventsWhereInput[]
    OR?: eventsWhereInput[]
    NOT?: eventsWhereInput | eventsWhereInput[]
    name?: StringFilter<"events"> | string
    description?: StringNullableFilter<"events"> | string | null
    created_at?: DateTimeFilter<"events"> | Date | string
    user_id?: UuidFilter<"events"> | string
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
    locations?: LocationsListRelationFilter
    sessions?: SessionsListRelationFilter
  }, "id" | "code">

  export type eventsOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    code?: SortOrder
    created_at?: SortOrder
    user_id?: SortOrder
    _count?: eventsCountOrderByAggregateInput
    _max?: eventsMaxOrderByAggregateInput
    _min?: eventsMinOrderByAggregateInput
  }

  export type eventsScalarWhereWithAggregatesInput = {
    AND?: eventsScalarWhereWithAggregatesInput | eventsScalarWhereWithAggregatesInput[]
    OR?: eventsScalarWhereWithAggregatesInput[]
    NOT?: eventsScalarWhereWithAggregatesInput | eventsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"events"> | string
    name?: StringWithAggregatesFilter<"events"> | string
    description?: StringNullableWithAggregatesFilter<"events"> | string | null
    code?: StringWithAggregatesFilter<"events"> | string
    created_at?: DateTimeWithAggregatesFilter<"events"> | Date | string
    user_id?: UuidWithAggregatesFilter<"events"> | string
  }

  export type resourcesWhereInput = {
    AND?: resourcesWhereInput | resourcesWhereInput[]
    OR?: resourcesWhereInput[]
    NOT?: resourcesWhereInput | resourcesWhereInput[]
    id?: UuidFilter<"resources"> | string
    name?: StringFilter<"resources"> | string
    type?: StringNullableFilter<"resources"> | string | null
    description?: StringNullableFilter<"resources"> | string | null
    instance_role?: StringNullableFilter<"resources"> | string | null
    relations?: StringNullableFilter<"resources"> | string | null
    attributes?: JsonNullableFilter<"resources">
    created_at?: DateTimeFilter<"resources"> | Date | string
    updated_at?: DateTimeFilter<"resources"> | Date | string
    permissions?: PermissionsListRelationFilter
  }

  export type resourcesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    instance_role?: SortOrderInput | SortOrder
    relations?: SortOrderInput | SortOrder
    attributes?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    permissions?: permissionsOrderByRelationAggregateInput
  }

  export type resourcesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    AND?: resourcesWhereInput | resourcesWhereInput[]
    OR?: resourcesWhereInput[]
    NOT?: resourcesWhereInput | resourcesWhereInput[]
    type?: StringNullableFilter<"resources"> | string | null
    description?: StringNullableFilter<"resources"> | string | null
    instance_role?: StringNullableFilter<"resources"> | string | null
    relations?: StringNullableFilter<"resources"> | string | null
    attributes?: JsonNullableFilter<"resources">
    created_at?: DateTimeFilter<"resources"> | Date | string
    updated_at?: DateTimeFilter<"resources"> | Date | string
    permissions?: PermissionsListRelationFilter
  }, "id" | "name">

  export type resourcesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    instance_role?: SortOrderInput | SortOrder
    relations?: SortOrderInput | SortOrder
    attributes?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: resourcesCountOrderByAggregateInput
    _max?: resourcesMaxOrderByAggregateInput
    _min?: resourcesMinOrderByAggregateInput
  }

  export type resourcesScalarWhereWithAggregatesInput = {
    AND?: resourcesScalarWhereWithAggregatesInput | resourcesScalarWhereWithAggregatesInput[]
    OR?: resourcesScalarWhereWithAggregatesInput[]
    NOT?: resourcesScalarWhereWithAggregatesInput | resourcesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"resources"> | string
    name?: StringWithAggregatesFilter<"resources"> | string
    type?: StringNullableWithAggregatesFilter<"resources"> | string | null
    description?: StringNullableWithAggregatesFilter<"resources"> | string | null
    instance_role?: StringNullableWithAggregatesFilter<"resources"> | string | null
    relations?: StringNullableWithAggregatesFilter<"resources"> | string | null
    attributes?: JsonNullableWithAggregatesFilter<"resources">
    created_at?: DateTimeWithAggregatesFilter<"resources"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"resources"> | Date | string
  }

  export type permissionsWhereInput = {
    AND?: permissionsWhereInput | permissionsWhereInput[]
    OR?: permissionsWhereInput[]
    NOT?: permissionsWhereInput | permissionsWhereInput[]
    id?: UuidFilter<"permissions"> | string
    action?: StringFilter<"permissions"> | string
    resource_id?: UuidFilter<"permissions"> | string
    role_id?: UuidFilter<"permissions"> | string
    created_at?: DateTimeFilter<"permissions"> | Date | string
    updated_at?: DateTimeFilter<"permissions"> | Date | string
    resource?: XOR<ResourcesScalarRelationFilter, resourcesWhereInput>
    role?: XOR<RolesScalarRelationFilter, rolesWhereInput>
  }

  export type permissionsOrderByWithRelationInput = {
    id?: SortOrder
    action?: SortOrder
    resource_id?: SortOrder
    role_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    resource?: resourcesOrderByWithRelationInput
    role?: rolesOrderByWithRelationInput
  }

  export type permissionsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: permissionsWhereInput | permissionsWhereInput[]
    OR?: permissionsWhereInput[]
    NOT?: permissionsWhereInput | permissionsWhereInput[]
    action?: StringFilter<"permissions"> | string
    resource_id?: UuidFilter<"permissions"> | string
    role_id?: UuidFilter<"permissions"> | string
    created_at?: DateTimeFilter<"permissions"> | Date | string
    updated_at?: DateTimeFilter<"permissions"> | Date | string
    resource?: XOR<ResourcesScalarRelationFilter, resourcesWhereInput>
    role?: XOR<RolesScalarRelationFilter, rolesWhereInput>
  }, "id">

  export type permissionsOrderByWithAggregationInput = {
    id?: SortOrder
    action?: SortOrder
    resource_id?: SortOrder
    role_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: permissionsCountOrderByAggregateInput
    _max?: permissionsMaxOrderByAggregateInput
    _min?: permissionsMinOrderByAggregateInput
  }

  export type permissionsScalarWhereWithAggregatesInput = {
    AND?: permissionsScalarWhereWithAggregatesInput | permissionsScalarWhereWithAggregatesInput[]
    OR?: permissionsScalarWhereWithAggregatesInput[]
    NOT?: permissionsScalarWhereWithAggregatesInput | permissionsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"permissions"> | string
    action?: StringWithAggregatesFilter<"permissions"> | string
    resource_id?: UuidWithAggregatesFilter<"permissions"> | string
    role_id?: UuidWithAggregatesFilter<"permissions"> | string
    created_at?: DateTimeWithAggregatesFilter<"permissions"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"permissions"> | Date | string
  }

  export type citiesWhereInput = {
    AND?: citiesWhereInput | citiesWhereInput[]
    OR?: citiesWhereInput[]
    NOT?: citiesWhereInput | citiesWhereInput[]
    id?: StringFilter<"cities"> | string
    name?: StringFilter<"cities"> | string
    created_at?: DateTimeNullableFilter<"cities"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"cities"> | Date | string | null
    districts?: DistrictsListRelationFilter
    units?: UnitsListRelationFilter
  }

  export type citiesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    districts?: districtsOrderByRelationAggregateInput
    units?: unitsOrderByRelationAggregateInput
  }

  export type citiesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: citiesWhereInput | citiesWhereInput[]
    OR?: citiesWhereInput[]
    NOT?: citiesWhereInput | citiesWhereInput[]
    name?: StringFilter<"cities"> | string
    created_at?: DateTimeNullableFilter<"cities"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"cities"> | Date | string | null
    districts?: DistrictsListRelationFilter
    units?: UnitsListRelationFilter
  }, "id">

  export type citiesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: citiesCountOrderByAggregateInput
    _max?: citiesMaxOrderByAggregateInput
    _min?: citiesMinOrderByAggregateInput
  }

  export type citiesScalarWhereWithAggregatesInput = {
    AND?: citiesScalarWhereWithAggregatesInput | citiesScalarWhereWithAggregatesInput[]
    OR?: citiesScalarWhereWithAggregatesInput[]
    NOT?: citiesScalarWhereWithAggregatesInput | citiesScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"cities"> | string
    name?: StringWithAggregatesFilter<"cities"> | string
    created_at?: DateTimeNullableWithAggregatesFilter<"cities"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"cities"> | Date | string | null
  }

  export type crime_incidentsWhereInput = {
    AND?: crime_incidentsWhereInput | crime_incidentsWhereInput[]
    OR?: crime_incidentsWhereInput[]
    NOT?: crime_incidentsWhereInput | crime_incidentsWhereInput[]
    id?: StringFilter<"crime_incidents"> | string
    crime_id?: StringFilter<"crime_incidents"> | string
    crime_category_id?: StringFilter<"crime_incidents"> | string
    location_id?: UuidFilter<"crime_incidents"> | string
    description?: StringFilter<"crime_incidents"> | string
    victim_count?: IntFilter<"crime_incidents"> | number
    status?: Enumcrime_statusNullableFilter<"crime_incidents"> | $Enums.crime_status | null
    created_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    timestamp?: DateTimeFilter<"crime_incidents"> | Date | string
    crime_categories?: XOR<Crime_categoriesScalarRelationFilter, crime_categoriesWhereInput>
    crimes?: XOR<CrimesScalarRelationFilter, crimesWhereInput>
    locations?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    evidences?: EvidenceListRelationFilter
    timelines?: TimelinesListRelationFilter
    witnesses?: WitnessesListRelationFilter
  }

  export type crime_incidentsOrderByWithRelationInput = {
    id?: SortOrder
    crime_id?: SortOrder
    crime_category_id?: SortOrder
    location_id?: SortOrder
    description?: SortOrder
    victim_count?: SortOrder
    status?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    crime_categories?: crime_categoriesOrderByWithRelationInput
    crimes?: crimesOrderByWithRelationInput
    locations?: locationsOrderByWithRelationInput
    evidences?: evidenceOrderByRelationAggregateInput
    timelines?: timelinesOrderByRelationAggregateInput
    witnesses?: witnessesOrderByRelationAggregateInput
  }

  export type crime_incidentsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: crime_incidentsWhereInput | crime_incidentsWhereInput[]
    OR?: crime_incidentsWhereInput[]
    NOT?: crime_incidentsWhereInput | crime_incidentsWhereInput[]
    crime_id?: StringFilter<"crime_incidents"> | string
    crime_category_id?: StringFilter<"crime_incidents"> | string
    location_id?: UuidFilter<"crime_incidents"> | string
    description?: StringFilter<"crime_incidents"> | string
    victim_count?: IntFilter<"crime_incidents"> | number
    status?: Enumcrime_statusNullableFilter<"crime_incidents"> | $Enums.crime_status | null
    created_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    timestamp?: DateTimeFilter<"crime_incidents"> | Date | string
    crime_categories?: XOR<Crime_categoriesScalarRelationFilter, crime_categoriesWhereInput>
    crimes?: XOR<CrimesScalarRelationFilter, crimesWhereInput>
    locations?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    evidences?: EvidenceListRelationFilter
    timelines?: TimelinesListRelationFilter
    witnesses?: WitnessesListRelationFilter
  }, "id">

  export type crime_incidentsOrderByWithAggregationInput = {
    id?: SortOrder
    crime_id?: SortOrder
    crime_category_id?: SortOrder
    location_id?: SortOrder
    description?: SortOrder
    victim_count?: SortOrder
    status?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    _count?: crime_incidentsCountOrderByAggregateInput
    _avg?: crime_incidentsAvgOrderByAggregateInput
    _max?: crime_incidentsMaxOrderByAggregateInput
    _min?: crime_incidentsMinOrderByAggregateInput
    _sum?: crime_incidentsSumOrderByAggregateInput
  }

  export type crime_incidentsScalarWhereWithAggregatesInput = {
    AND?: crime_incidentsScalarWhereWithAggregatesInput | crime_incidentsScalarWhereWithAggregatesInput[]
    OR?: crime_incidentsScalarWhereWithAggregatesInput[]
    NOT?: crime_incidentsScalarWhereWithAggregatesInput | crime_incidentsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"crime_incidents"> | string
    crime_id?: StringWithAggregatesFilter<"crime_incidents"> | string
    crime_category_id?: StringWithAggregatesFilter<"crime_incidents"> | string
    location_id?: UuidWithAggregatesFilter<"crime_incidents"> | string
    description?: StringWithAggregatesFilter<"crime_incidents"> | string
    victim_count?: IntWithAggregatesFilter<"crime_incidents"> | number
    status?: Enumcrime_statusNullableWithAggregatesFilter<"crime_incidents"> | $Enums.crime_status | null
    created_at?: DateTimeNullableWithAggregatesFilter<"crime_incidents"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"crime_incidents"> | Date | string | null
    timestamp?: DateTimeWithAggregatesFilter<"crime_incidents"> | Date | string
  }

  export type crime_categoriesWhereInput = {
    AND?: crime_categoriesWhereInput | crime_categoriesWhereInput[]
    OR?: crime_categoriesWhereInput[]
    NOT?: crime_categoriesWhereInput | crime_categoriesWhereInput[]
    id?: StringFilter<"crime_categories"> | string
    name?: StringFilter<"crime_categories"> | string
    description?: StringFilter<"crime_categories"> | string
    created_at?: DateTimeNullableFilter<"crime_categories"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"crime_categories"> | Date | string | null
    type?: StringNullableFilter<"crime_categories"> | string | null
    crime_incidents?: Crime_incidentsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
  }

  export type crime_categoriesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    crime_incidents?: crime_incidentsOrderByRelationAggregateInput
    incident_logs?: incident_logsOrderByRelationAggregateInput
  }

  export type crime_categoriesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: crime_categoriesWhereInput | crime_categoriesWhereInput[]
    OR?: crime_categoriesWhereInput[]
    NOT?: crime_categoriesWhereInput | crime_categoriesWhereInput[]
    name?: StringFilter<"crime_categories"> | string
    description?: StringFilter<"crime_categories"> | string
    created_at?: DateTimeNullableFilter<"crime_categories"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"crime_categories"> | Date | string | null
    type?: StringNullableFilter<"crime_categories"> | string | null
    crime_incidents?: Crime_incidentsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
  }, "id">

  export type crime_categoriesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    _count?: crime_categoriesCountOrderByAggregateInput
    _max?: crime_categoriesMaxOrderByAggregateInput
    _min?: crime_categoriesMinOrderByAggregateInput
  }

  export type crime_categoriesScalarWhereWithAggregatesInput = {
    AND?: crime_categoriesScalarWhereWithAggregatesInput | crime_categoriesScalarWhereWithAggregatesInput[]
    OR?: crime_categoriesScalarWhereWithAggregatesInput[]
    NOT?: crime_categoriesScalarWhereWithAggregatesInput | crime_categoriesScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"crime_categories"> | string
    name?: StringWithAggregatesFilter<"crime_categories"> | string
    description?: StringWithAggregatesFilter<"crime_categories"> | string
    created_at?: DateTimeNullableWithAggregatesFilter<"crime_categories"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"crime_categories"> | Date | string | null
    type?: StringNullableWithAggregatesFilter<"crime_categories"> | string | null
  }

  export type crimesWhereInput = {
    AND?: crimesWhereInput | crimesWhereInput[]
    OR?: crimesWhereInput[]
    NOT?: crimesWhereInput | crimesWhereInput[]
    id?: StringFilter<"crimes"> | string
    district_id?: StringFilter<"crimes"> | string
    created_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    level?: Enumcrime_ratesFilter<"crimes"> | $Enums.crime_rates
    method?: StringNullableFilter<"crimes"> | string | null
    month?: IntNullableFilter<"crimes"> | number | null
    number_of_crime?: IntFilter<"crimes"> | number
    score?: FloatFilter<"crimes"> | number
    updated_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    year?: IntNullableFilter<"crimes"> | number | null
    source_type?: StringNullableFilter<"crimes"> | string | null
    crime_cleared?: IntFilter<"crimes"> | number
    avg_crime?: FloatFilter<"crimes"> | number
    crime_incidents?: Crime_incidentsListRelationFilter
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }

  export type crimesOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    created_at?: SortOrderInput | SortOrder
    level?: SortOrder
    method?: SortOrderInput | SortOrder
    month?: SortOrderInput | SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    updated_at?: SortOrderInput | SortOrder
    year?: SortOrderInput | SortOrder
    source_type?: SortOrderInput | SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
    crime_incidents?: crime_incidentsOrderByRelationAggregateInput
    districts?: districtsOrderByWithRelationInput
  }

  export type crimesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: crimesWhereInput | crimesWhereInput[]
    OR?: crimesWhereInput[]
    NOT?: crimesWhereInput | crimesWhereInput[]
    district_id?: StringFilter<"crimes"> | string
    created_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    level?: Enumcrime_ratesFilter<"crimes"> | $Enums.crime_rates
    method?: StringNullableFilter<"crimes"> | string | null
    month?: IntNullableFilter<"crimes"> | number | null
    number_of_crime?: IntFilter<"crimes"> | number
    score?: FloatFilter<"crimes"> | number
    updated_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    year?: IntNullableFilter<"crimes"> | number | null
    source_type?: StringNullableFilter<"crimes"> | string | null
    crime_cleared?: IntFilter<"crimes"> | number
    avg_crime?: FloatFilter<"crimes"> | number
    crime_incidents?: Crime_incidentsListRelationFilter
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }, "id">

  export type crimesOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    created_at?: SortOrderInput | SortOrder
    level?: SortOrder
    method?: SortOrderInput | SortOrder
    month?: SortOrderInput | SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    updated_at?: SortOrderInput | SortOrder
    year?: SortOrderInput | SortOrder
    source_type?: SortOrderInput | SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
    _count?: crimesCountOrderByAggregateInput
    _avg?: crimesAvgOrderByAggregateInput
    _max?: crimesMaxOrderByAggregateInput
    _min?: crimesMinOrderByAggregateInput
    _sum?: crimesSumOrderByAggregateInput
  }

  export type crimesScalarWhereWithAggregatesInput = {
    AND?: crimesScalarWhereWithAggregatesInput | crimesScalarWhereWithAggregatesInput[]
    OR?: crimesScalarWhereWithAggregatesInput[]
    NOT?: crimesScalarWhereWithAggregatesInput | crimesScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"crimes"> | string
    district_id?: StringWithAggregatesFilter<"crimes"> | string
    created_at?: DateTimeNullableWithAggregatesFilter<"crimes"> | Date | string | null
    level?: Enumcrime_ratesWithAggregatesFilter<"crimes"> | $Enums.crime_rates
    method?: StringNullableWithAggregatesFilter<"crimes"> | string | null
    month?: IntNullableWithAggregatesFilter<"crimes"> | number | null
    number_of_crime?: IntWithAggregatesFilter<"crimes"> | number
    score?: FloatWithAggregatesFilter<"crimes"> | number
    updated_at?: DateTimeNullableWithAggregatesFilter<"crimes"> | Date | string | null
    year?: IntNullableWithAggregatesFilter<"crimes"> | number | null
    source_type?: StringNullableWithAggregatesFilter<"crimes"> | string | null
    crime_cleared?: IntWithAggregatesFilter<"crimes"> | number
    avg_crime?: FloatWithAggregatesFilter<"crimes"> | number
  }

  export type demographicsWhereInput = {
    AND?: demographicsWhereInput | demographicsWhereInput[]
    OR?: demographicsWhereInput[]
    NOT?: demographicsWhereInput | demographicsWhereInput[]
    id?: UuidFilter<"demographics"> | string
    district_id?: StringFilter<"demographics"> | string
    population?: IntFilter<"demographics"> | number
    number_of_unemployed?: IntFilter<"demographics"> | number
    population_density?: FloatFilter<"demographics"> | number
    year?: IntFilter<"demographics"> | number
    created_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }

  export type demographicsOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    districts?: districtsOrderByWithRelationInput
  }

  export type demographicsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    district_id_year?: demographicsDistrict_idYearCompoundUniqueInput
    AND?: demographicsWhereInput | demographicsWhereInput[]
    OR?: demographicsWhereInput[]
    NOT?: demographicsWhereInput | demographicsWhereInput[]
    district_id?: StringFilter<"demographics"> | string
    population?: IntFilter<"demographics"> | number
    number_of_unemployed?: IntFilter<"demographics"> | number
    population_density?: FloatFilter<"demographics"> | number
    year?: IntFilter<"demographics"> | number
    created_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }, "id" | "district_id_year">

  export type demographicsOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: demographicsCountOrderByAggregateInput
    _avg?: demographicsAvgOrderByAggregateInput
    _max?: demographicsMaxOrderByAggregateInput
    _min?: demographicsMinOrderByAggregateInput
    _sum?: demographicsSumOrderByAggregateInput
  }

  export type demographicsScalarWhereWithAggregatesInput = {
    AND?: demographicsScalarWhereWithAggregatesInput | demographicsScalarWhereWithAggregatesInput[]
    OR?: demographicsScalarWhereWithAggregatesInput[]
    NOT?: demographicsScalarWhereWithAggregatesInput | demographicsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"demographics"> | string
    district_id?: StringWithAggregatesFilter<"demographics"> | string
    population?: IntWithAggregatesFilter<"demographics"> | number
    number_of_unemployed?: IntWithAggregatesFilter<"demographics"> | number
    population_density?: FloatWithAggregatesFilter<"demographics"> | number
    year?: IntWithAggregatesFilter<"demographics"> | number
    created_at?: DateTimeNullableWithAggregatesFilter<"demographics"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"demographics"> | Date | string | null
  }

  export type districtsWhereInput = {
    AND?: districtsWhereInput | districtsWhereInput[]
    OR?: districtsWhereInput[]
    NOT?: districtsWhereInput | districtsWhereInput[]
    id?: StringFilter<"districts"> | string
    city_id?: StringFilter<"districts"> | string
    name?: StringFilter<"districts"> | string
    created_at?: DateTimeNullableFilter<"districts"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"districts"> | Date | string | null
    crimes?: CrimesListRelationFilter
    demographics?: DemographicsListRelationFilter
    district_clusters?: District_clustersListRelationFilter
    cities?: XOR<CitiesScalarRelationFilter, citiesWhereInput>
    geographics?: GeographicsListRelationFilter
    locations?: LocationsListRelationFilter
    units?: XOR<UnitsNullableScalarRelationFilter, unitsWhereInput> | null
  }

  export type districtsOrderByWithRelationInput = {
    id?: SortOrder
    city_id?: SortOrder
    name?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    crimes?: crimesOrderByRelationAggregateInput
    demographics?: demographicsOrderByRelationAggregateInput
    district_clusters?: district_clustersOrderByRelationAggregateInput
    cities?: citiesOrderByWithRelationInput
    geographics?: geographicsOrderByRelationAggregateInput
    locations?: locationsOrderByRelationAggregateInput
    units?: unitsOrderByWithRelationInput
  }

  export type districtsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: districtsWhereInput | districtsWhereInput[]
    OR?: districtsWhereInput[]
    NOT?: districtsWhereInput | districtsWhereInput[]
    city_id?: StringFilter<"districts"> | string
    name?: StringFilter<"districts"> | string
    created_at?: DateTimeNullableFilter<"districts"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"districts"> | Date | string | null
    crimes?: CrimesListRelationFilter
    demographics?: DemographicsListRelationFilter
    district_clusters?: District_clustersListRelationFilter
    cities?: XOR<CitiesScalarRelationFilter, citiesWhereInput>
    geographics?: GeographicsListRelationFilter
    locations?: LocationsListRelationFilter
    units?: XOR<UnitsNullableScalarRelationFilter, unitsWhereInput> | null
  }, "id">

  export type districtsOrderByWithAggregationInput = {
    id?: SortOrder
    city_id?: SortOrder
    name?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: districtsCountOrderByAggregateInput
    _max?: districtsMaxOrderByAggregateInput
    _min?: districtsMinOrderByAggregateInput
  }

  export type districtsScalarWhereWithAggregatesInput = {
    AND?: districtsScalarWhereWithAggregatesInput | districtsScalarWhereWithAggregatesInput[]
    OR?: districtsScalarWhereWithAggregatesInput[]
    NOT?: districtsScalarWhereWithAggregatesInput | districtsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"districts"> | string
    city_id?: StringWithAggregatesFilter<"districts"> | string
    name?: StringWithAggregatesFilter<"districts"> | string
    created_at?: DateTimeNullableWithAggregatesFilter<"districts"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"districts"> | Date | string | null
  }

  export type locationsWhereInput = {
    AND?: locationsWhereInput | locationsWhereInput[]
    OR?: locationsWhereInput[]
    NOT?: locationsWhereInput | locationsWhereInput[]
    id?: UuidFilter<"locations"> | string
    district_id?: StringFilter<"locations"> | string
    event_id?: UuidFilter<"locations"> | string
    address?: StringNullableFilter<"locations"> | string | null
    type?: StringNullableFilter<"locations"> | string | null
    latitude?: FloatFilter<"locations"> | number
    longitude?: FloatFilter<"locations"> | number
    land_area?: FloatNullableFilter<"locations"> | number | null
    created_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    distance_to_unit?: FloatNullableFilter<"locations"> | number | null
    crime_incidents?: Crime_incidentsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
    location_logs?: Location_logsListRelationFilter
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
    event?: XOR<EventsScalarRelationFilter, eventsWhereInput>
    patrol_units?: Patrol_unitsListRelationFilter
  }

  export type locationsOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    event_id?: SortOrder
    address?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    distance_to_unit?: SortOrderInput | SortOrder
    crime_incidents?: crime_incidentsOrderByRelationAggregateInput
    incident_logs?: incident_logsOrderByRelationAggregateInput
    location_logs?: location_logsOrderByRelationAggregateInput
    districts?: districtsOrderByWithRelationInput
    event?: eventsOrderByWithRelationInput
    patrol_units?: patrol_unitsOrderByRelationAggregateInput
  }

  export type locationsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: locationsWhereInput | locationsWhereInput[]
    OR?: locationsWhereInput[]
    NOT?: locationsWhereInput | locationsWhereInput[]
    district_id?: StringFilter<"locations"> | string
    event_id?: UuidFilter<"locations"> | string
    address?: StringNullableFilter<"locations"> | string | null
    type?: StringNullableFilter<"locations"> | string | null
    latitude?: FloatFilter<"locations"> | number
    longitude?: FloatFilter<"locations"> | number
    land_area?: FloatNullableFilter<"locations"> | number | null
    created_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    distance_to_unit?: FloatNullableFilter<"locations"> | number | null
    crime_incidents?: Crime_incidentsListRelationFilter
    incident_logs?: Incident_logsListRelationFilter
    location_logs?: Location_logsListRelationFilter
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
    event?: XOR<EventsScalarRelationFilter, eventsWhereInput>
    patrol_units?: Patrol_unitsListRelationFilter
  }, "id">

  export type locationsOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    event_id?: SortOrder
    address?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    distance_to_unit?: SortOrderInput | SortOrder
    _count?: locationsCountOrderByAggregateInput
    _avg?: locationsAvgOrderByAggregateInput
    _max?: locationsMaxOrderByAggregateInput
    _min?: locationsMinOrderByAggregateInput
    _sum?: locationsSumOrderByAggregateInput
  }

  export type locationsScalarWhereWithAggregatesInput = {
    AND?: locationsScalarWhereWithAggregatesInput | locationsScalarWhereWithAggregatesInput[]
    OR?: locationsScalarWhereWithAggregatesInput[]
    NOT?: locationsScalarWhereWithAggregatesInput | locationsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"locations"> | string
    district_id?: StringWithAggregatesFilter<"locations"> | string
    event_id?: UuidWithAggregatesFilter<"locations"> | string
    address?: StringNullableWithAggregatesFilter<"locations"> | string | null
    type?: StringNullableWithAggregatesFilter<"locations"> | string | null
    latitude?: FloatWithAggregatesFilter<"locations"> | number
    longitude?: FloatWithAggregatesFilter<"locations"> | number
    land_area?: FloatNullableWithAggregatesFilter<"locations"> | number | null
    created_at?: DateTimeNullableWithAggregatesFilter<"locations"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"locations"> | Date | string | null
    distance_to_unit?: FloatNullableWithAggregatesFilter<"locations"> | number | null
  }

  export type incident_logsWhereInput = {
    AND?: incident_logsWhereInput | incident_logsWhereInput[]
    OR?: incident_logsWhereInput[]
    NOT?: incident_logsWhereInput | incident_logsWhereInput[]
    id?: UuidFilter<"incident_logs"> | string
    user_id?: UuidFilter<"incident_logs"> | string
    location_id?: UuidFilter<"incident_logs"> | string
    category_id?: StringFilter<"incident_logs"> | string
    description?: StringNullableFilter<"incident_logs"> | string | null
    source?: StringNullableFilter<"incident_logs"> | string | null
    time?: DateTimeFilter<"incident_logs"> | Date | string
    verified?: BoolNullableFilter<"incident_logs"> | boolean | null
    severity?: StringNullableFilter<"incident_logs"> | string | null
    created_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
    evidence?: EvidenceListRelationFilter
    crime_categories?: XOR<Crime_categoriesScalarRelationFilter, crime_categoriesWhereInput>
    locations?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
    panic_button_logs?: Panic_button_logsListRelationFilter
    timelines?: TimelinesListRelationFilter
    witnesses?: WitnessesListRelationFilter
  }

  export type incident_logsOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    location_id?: SortOrder
    category_id?: SortOrder
    description?: SortOrderInput | SortOrder
    source?: SortOrderInput | SortOrder
    time?: SortOrder
    verified?: SortOrderInput | SortOrder
    severity?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    evidence?: evidenceOrderByRelationAggregateInput
    crime_categories?: crime_categoriesOrderByWithRelationInput
    locations?: locationsOrderByWithRelationInput
    user?: usersOrderByWithRelationInput
    panic_button_logs?: panic_button_logsOrderByRelationAggregateInput
    timelines?: timelinesOrderByRelationAggregateInput
    witnesses?: witnessesOrderByRelationAggregateInput
  }

  export type incident_logsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: incident_logsWhereInput | incident_logsWhereInput[]
    OR?: incident_logsWhereInput[]
    NOT?: incident_logsWhereInput | incident_logsWhereInput[]
    user_id?: UuidFilter<"incident_logs"> | string
    location_id?: UuidFilter<"incident_logs"> | string
    category_id?: StringFilter<"incident_logs"> | string
    description?: StringNullableFilter<"incident_logs"> | string | null
    source?: StringNullableFilter<"incident_logs"> | string | null
    time?: DateTimeFilter<"incident_logs"> | Date | string
    verified?: BoolNullableFilter<"incident_logs"> | boolean | null
    severity?: StringNullableFilter<"incident_logs"> | string | null
    created_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
    evidence?: EvidenceListRelationFilter
    crime_categories?: XOR<Crime_categoriesScalarRelationFilter, crime_categoriesWhereInput>
    locations?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
    panic_button_logs?: Panic_button_logsListRelationFilter
    timelines?: TimelinesListRelationFilter
    witnesses?: WitnessesListRelationFilter
  }, "id">

  export type incident_logsOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    location_id?: SortOrder
    category_id?: SortOrder
    description?: SortOrderInput | SortOrder
    source?: SortOrderInput | SortOrder
    time?: SortOrder
    verified?: SortOrderInput | SortOrder
    severity?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: incident_logsCountOrderByAggregateInput
    _max?: incident_logsMaxOrderByAggregateInput
    _min?: incident_logsMinOrderByAggregateInput
  }

  export type incident_logsScalarWhereWithAggregatesInput = {
    AND?: incident_logsScalarWhereWithAggregatesInput | incident_logsScalarWhereWithAggregatesInput[]
    OR?: incident_logsScalarWhereWithAggregatesInput[]
    NOT?: incident_logsScalarWhereWithAggregatesInput | incident_logsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"incident_logs"> | string
    user_id?: UuidWithAggregatesFilter<"incident_logs"> | string
    location_id?: UuidWithAggregatesFilter<"incident_logs"> | string
    category_id?: StringWithAggregatesFilter<"incident_logs"> | string
    description?: StringNullableWithAggregatesFilter<"incident_logs"> | string | null
    source?: StringNullableWithAggregatesFilter<"incident_logs"> | string | null
    time?: DateTimeWithAggregatesFilter<"incident_logs"> | Date | string
    verified?: BoolNullableWithAggregatesFilter<"incident_logs"> | boolean | null
    severity?: StringNullableWithAggregatesFilter<"incident_logs"> | string | null
    created_at?: DateTimeNullableWithAggregatesFilter<"incident_logs"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"incident_logs"> | Date | string | null
  }

  export type timelinesWhereInput = {
    AND?: timelinesWhereInput | timelinesWhereInput[]
    OR?: timelinesWhereInput[]
    NOT?: timelinesWhereInput | timelinesWhereInput[]
    id?: UuidFilter<"timelines"> | string
    incident_logs_id?: UuidNullableFilter<"timelines"> | string | null
    crime_incidents_id?: StringNullableFilter<"timelines"> | string | null
    user_id?: UuidNullableFilter<"timelines"> | string | null
    title?: StringNullableFilter<"timelines"> | string | null
    description?: StringNullableFilter<"timelines"> | string | null
    timestamp?: DateTimeFilter<"timelines"> | Date | string
    created_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
    user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
  }

  export type timelinesOrderByWithRelationInput = {
    id?: SortOrder
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    title?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    crime_incidents?: crime_incidentsOrderByWithRelationInput
    incident?: incident_logsOrderByWithRelationInput
    user?: usersOrderByWithRelationInput
  }

  export type timelinesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: timelinesWhereInput | timelinesWhereInput[]
    OR?: timelinesWhereInput[]
    NOT?: timelinesWhereInput | timelinesWhereInput[]
    incident_logs_id?: UuidNullableFilter<"timelines"> | string | null
    crime_incidents_id?: StringNullableFilter<"timelines"> | string | null
    user_id?: UuidNullableFilter<"timelines"> | string | null
    title?: StringNullableFilter<"timelines"> | string | null
    description?: StringNullableFilter<"timelines"> | string | null
    timestamp?: DateTimeFilter<"timelines"> | Date | string
    created_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
    user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
  }, "id">

  export type timelinesOrderByWithAggregationInput = {
    id?: SortOrder
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    title?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: timelinesCountOrderByAggregateInput
    _max?: timelinesMaxOrderByAggregateInput
    _min?: timelinesMinOrderByAggregateInput
  }

  export type timelinesScalarWhereWithAggregatesInput = {
    AND?: timelinesScalarWhereWithAggregatesInput | timelinesScalarWhereWithAggregatesInput[]
    OR?: timelinesScalarWhereWithAggregatesInput[]
    NOT?: timelinesScalarWhereWithAggregatesInput | timelinesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"timelines"> | string
    incident_logs_id?: UuidNullableWithAggregatesFilter<"timelines"> | string | null
    crime_incidents_id?: StringNullableWithAggregatesFilter<"timelines"> | string | null
    user_id?: UuidNullableWithAggregatesFilter<"timelines"> | string | null
    title?: StringNullableWithAggregatesFilter<"timelines"> | string | null
    description?: StringNullableWithAggregatesFilter<"timelines"> | string | null
    timestamp?: DateTimeWithAggregatesFilter<"timelines"> | Date | string
    created_at?: DateTimeNullableWithAggregatesFilter<"timelines"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"timelines"> | Date | string | null
  }

  export type witnessesWhereInput = {
    AND?: witnessesWhereInput | witnessesWhereInput[]
    OR?: witnessesWhereInput[]
    NOT?: witnessesWhereInput | witnessesWhereInput[]
    id?: UuidFilter<"witnesses"> | string
    incident_logs_id?: UuidNullableFilter<"witnesses"> | string | null
    crime_incidents_id?: StringNullableFilter<"witnesses"> | string | null
    name?: StringNullableFilter<"witnesses"> | string | null
    contact_info?: StringNullableFilter<"witnesses"> | string | null
    statement?: StringNullableFilter<"witnesses"> | string | null
    created_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
  }

  export type witnessesOrderByWithRelationInput = {
    id?: SortOrder
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    contact_info?: SortOrderInput | SortOrder
    statement?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    crime_incidents?: crime_incidentsOrderByWithRelationInput
    incident?: incident_logsOrderByWithRelationInput
  }

  export type witnessesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: witnessesWhereInput | witnessesWhereInput[]
    OR?: witnessesWhereInput[]
    NOT?: witnessesWhereInput | witnessesWhereInput[]
    incident_logs_id?: UuidNullableFilter<"witnesses"> | string | null
    crime_incidents_id?: StringNullableFilter<"witnesses"> | string | null
    name?: StringNullableFilter<"witnesses"> | string | null
    contact_info?: StringNullableFilter<"witnesses"> | string | null
    statement?: StringNullableFilter<"witnesses"> | string | null
    created_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
  }, "id">

  export type witnessesOrderByWithAggregationInput = {
    id?: SortOrder
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    contact_info?: SortOrderInput | SortOrder
    statement?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: witnessesCountOrderByAggregateInput
    _max?: witnessesMaxOrderByAggregateInput
    _min?: witnessesMinOrderByAggregateInput
  }

  export type witnessesScalarWhereWithAggregatesInput = {
    AND?: witnessesScalarWhereWithAggregatesInput | witnessesScalarWhereWithAggregatesInput[]
    OR?: witnessesScalarWhereWithAggregatesInput[]
    NOT?: witnessesScalarWhereWithAggregatesInput | witnessesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"witnesses"> | string
    incident_logs_id?: UuidNullableWithAggregatesFilter<"witnesses"> | string | null
    crime_incidents_id?: StringNullableWithAggregatesFilter<"witnesses"> | string | null
    name?: StringNullableWithAggregatesFilter<"witnesses"> | string | null
    contact_info?: StringNullableWithAggregatesFilter<"witnesses"> | string | null
    statement?: StringNullableWithAggregatesFilter<"witnesses"> | string | null
    created_at?: DateTimeNullableWithAggregatesFilter<"witnesses"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"witnesses"> | Date | string | null
  }

  export type evidenceWhereInput = {
    AND?: evidenceWhereInput | evidenceWhereInput[]
    OR?: evidenceWhereInput[]
    NOT?: evidenceWhereInput | evidenceWhereInput[]
    incident_logs_id?: UuidNullableFilter<"evidence"> | string | null
    crime_incidents_id?: StringNullableFilter<"evidence"> | string | null
    type?: StringFilter<"evidence"> | string
    url?: StringFilter<"evidence"> | string
    status?: StringNullableFilter<"evidence"> | string | null
    uploaded_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    caption?: StringNullableFilter<"evidence"> | string | null
    description?: StringNullableFilter<"evidence"> | string | null
    metadata?: JsonNullableFilter<"evidence">
    id?: StringFilter<"evidence"> | string
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
  }

  export type evidenceOrderByWithRelationInput = {
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    type?: SortOrder
    url?: SortOrder
    status?: SortOrderInput | SortOrder
    uploaded_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    caption?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    metadata?: SortOrderInput | SortOrder
    id?: SortOrder
    crime_incidents?: crime_incidentsOrderByWithRelationInput
    incident?: incident_logsOrderByWithRelationInput
  }

  export type evidenceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: evidenceWhereInput | evidenceWhereInput[]
    OR?: evidenceWhereInput[]
    NOT?: evidenceWhereInput | evidenceWhereInput[]
    incident_logs_id?: UuidNullableFilter<"evidence"> | string | null
    crime_incidents_id?: StringNullableFilter<"evidence"> | string | null
    type?: StringFilter<"evidence"> | string
    url?: StringFilter<"evidence"> | string
    status?: StringNullableFilter<"evidence"> | string | null
    uploaded_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    caption?: StringNullableFilter<"evidence"> | string | null
    description?: StringNullableFilter<"evidence"> | string | null
    metadata?: JsonNullableFilter<"evidence">
    crime_incidents?: XOR<Crime_incidentsNullableScalarRelationFilter, crime_incidentsWhereInput> | null
    incident?: XOR<Incident_logsNullableScalarRelationFilter, incident_logsWhereInput> | null
  }, "id" | "id">

  export type evidenceOrderByWithAggregationInput = {
    incident_logs_id?: SortOrderInput | SortOrder
    crime_incidents_id?: SortOrderInput | SortOrder
    type?: SortOrder
    url?: SortOrder
    status?: SortOrderInput | SortOrder
    uploaded_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    caption?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    metadata?: SortOrderInput | SortOrder
    id?: SortOrder
    _count?: evidenceCountOrderByAggregateInput
    _max?: evidenceMaxOrderByAggregateInput
    _min?: evidenceMinOrderByAggregateInput
  }

  export type evidenceScalarWhereWithAggregatesInput = {
    AND?: evidenceScalarWhereWithAggregatesInput | evidenceScalarWhereWithAggregatesInput[]
    OR?: evidenceScalarWhereWithAggregatesInput[]
    NOT?: evidenceScalarWhereWithAggregatesInput | evidenceScalarWhereWithAggregatesInput[]
    incident_logs_id?: UuidNullableWithAggregatesFilter<"evidence"> | string | null
    crime_incidents_id?: StringNullableWithAggregatesFilter<"evidence"> | string | null
    type?: StringWithAggregatesFilter<"evidence"> | string
    url?: StringWithAggregatesFilter<"evidence"> | string
    status?: StringNullableWithAggregatesFilter<"evidence"> | string | null
    uploaded_at?: DateTimeNullableWithAggregatesFilter<"evidence"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"evidence"> | Date | string | null
    caption?: StringNullableWithAggregatesFilter<"evidence"> | string | null
    description?: StringNullableWithAggregatesFilter<"evidence"> | string | null
    metadata?: JsonNullableWithAggregatesFilter<"evidence">
    id?: StringWithAggregatesFilter<"evidence"> | string
  }

  export type unitsWhereInput = {
    AND?: unitsWhereInput | unitsWhereInput[]
    OR?: unitsWhereInput[]
    NOT?: unitsWhereInput | unitsWhereInput[]
    code_unit?: StringFilter<"units"> | string
    district_id?: StringNullableFilter<"units"> | string | null
    name?: StringFilter<"units"> | string
    description?: StringNullableFilter<"units"> | string | null
    type?: Enumunit_typeFilter<"units"> | $Enums.unit_type
    created_at?: DateTimeNullableFilter<"units"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"units"> | Date | string | null
    address?: StringNullableFilter<"units"> | string | null
    land_area?: FloatNullableFilter<"units"> | number | null
    latitude?: FloatFilter<"units"> | number
    longitude?: FloatFilter<"units"> | number
    city_id?: StringFilter<"units"> | string
    phone?: StringNullableFilter<"units"> | string | null
    officers?: OfficersListRelationFilter
    patrol_units?: Patrol_unitsListRelationFilter
    unit_statistics?: Unit_statisticsListRelationFilter
    cities?: XOR<CitiesScalarRelationFilter, citiesWhereInput>
    districts?: XOR<DistrictsNullableScalarRelationFilter, districtsWhereInput> | null
  }

  export type unitsOrderByWithRelationInput = {
    code_unit?: SortOrder
    district_id?: SortOrderInput | SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    type?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    land_area?: SortOrderInput | SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    city_id?: SortOrder
    phone?: SortOrderInput | SortOrder
    officers?: officersOrderByRelationAggregateInput
    patrol_units?: patrol_unitsOrderByRelationAggregateInput
    unit_statistics?: unit_statisticsOrderByRelationAggregateInput
    cities?: citiesOrderByWithRelationInput
    districts?: districtsOrderByWithRelationInput
  }

  export type unitsWhereUniqueInput = Prisma.AtLeast<{
    code_unit?: string
    district_id?: string
    AND?: unitsWhereInput | unitsWhereInput[]
    OR?: unitsWhereInput[]
    NOT?: unitsWhereInput | unitsWhereInput[]
    name?: StringFilter<"units"> | string
    description?: StringNullableFilter<"units"> | string | null
    type?: Enumunit_typeFilter<"units"> | $Enums.unit_type
    created_at?: DateTimeNullableFilter<"units"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"units"> | Date | string | null
    address?: StringNullableFilter<"units"> | string | null
    land_area?: FloatNullableFilter<"units"> | number | null
    latitude?: FloatFilter<"units"> | number
    longitude?: FloatFilter<"units"> | number
    city_id?: StringFilter<"units"> | string
    phone?: StringNullableFilter<"units"> | string | null
    officers?: OfficersListRelationFilter
    patrol_units?: Patrol_unitsListRelationFilter
    unit_statistics?: Unit_statisticsListRelationFilter
    cities?: XOR<CitiesScalarRelationFilter, citiesWhereInput>
    districts?: XOR<DistrictsNullableScalarRelationFilter, districtsWhereInput> | null
  }, "code_unit" | "code_unit" | "district_id">

  export type unitsOrderByWithAggregationInput = {
    code_unit?: SortOrder
    district_id?: SortOrderInput | SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    type?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    land_area?: SortOrderInput | SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    city_id?: SortOrder
    phone?: SortOrderInput | SortOrder
    _count?: unitsCountOrderByAggregateInput
    _avg?: unitsAvgOrderByAggregateInput
    _max?: unitsMaxOrderByAggregateInput
    _min?: unitsMinOrderByAggregateInput
    _sum?: unitsSumOrderByAggregateInput
  }

  export type unitsScalarWhereWithAggregatesInput = {
    AND?: unitsScalarWhereWithAggregatesInput | unitsScalarWhereWithAggregatesInput[]
    OR?: unitsScalarWhereWithAggregatesInput[]
    NOT?: unitsScalarWhereWithAggregatesInput | unitsScalarWhereWithAggregatesInput[]
    code_unit?: StringWithAggregatesFilter<"units"> | string
    district_id?: StringNullableWithAggregatesFilter<"units"> | string | null
    name?: StringWithAggregatesFilter<"units"> | string
    description?: StringNullableWithAggregatesFilter<"units"> | string | null
    type?: Enumunit_typeWithAggregatesFilter<"units"> | $Enums.unit_type
    created_at?: DateTimeNullableWithAggregatesFilter<"units"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"units"> | Date | string | null
    address?: StringNullableWithAggregatesFilter<"units"> | string | null
    land_area?: FloatNullableWithAggregatesFilter<"units"> | number | null
    latitude?: FloatWithAggregatesFilter<"units"> | number
    longitude?: FloatWithAggregatesFilter<"units"> | number
    city_id?: StringWithAggregatesFilter<"units"> | string
    phone?: StringNullableWithAggregatesFilter<"units"> | string | null
  }

  export type patrol_unitsWhereInput = {
    AND?: patrol_unitsWhereInput | patrol_unitsWhereInput[]
    OR?: patrol_unitsWhereInput[]
    NOT?: patrol_unitsWhereInput | patrol_unitsWhereInput[]
    unit_id?: StringFilter<"patrol_units"> | string
    location_id?: UuidFilter<"patrol_units"> | string
    name?: StringFilter<"patrol_units"> | string
    type?: StringFilter<"patrol_units"> | string
    status?: StringFilter<"patrol_units"> | string
    radius?: FloatFilter<"patrol_units"> | number
    created_at?: DateTimeFilter<"patrol_units"> | Date | string
    id?: StringFilter<"patrol_units"> | string
    category?: Enumpatrol_unit_categoryNullableFilter<"patrol_units"> | $Enums.patrol_unit_category | null
    member_count?: IntNullableFilter<"patrol_units"> | number | null
    updated_at?: DateTimeNullableFilter<"patrol_units"> | Date | string | null
    members?: OfficersListRelationFilter
    location?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    unit?: XOR<UnitsScalarRelationFilter, unitsWhereInput>
  }

  export type patrol_unitsOrderByWithRelationInput = {
    unit_id?: SortOrder
    location_id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    status?: SortOrder
    radius?: SortOrder
    created_at?: SortOrder
    id?: SortOrder
    category?: SortOrderInput | SortOrder
    member_count?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    members?: officersOrderByRelationAggregateInput
    location?: locationsOrderByWithRelationInput
    unit?: unitsOrderByWithRelationInput
  }

  export type patrol_unitsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: patrol_unitsWhereInput | patrol_unitsWhereInput[]
    OR?: patrol_unitsWhereInput[]
    NOT?: patrol_unitsWhereInput | patrol_unitsWhereInput[]
    unit_id?: StringFilter<"patrol_units"> | string
    location_id?: UuidFilter<"patrol_units"> | string
    name?: StringFilter<"patrol_units"> | string
    type?: StringFilter<"patrol_units"> | string
    status?: StringFilter<"patrol_units"> | string
    radius?: FloatFilter<"patrol_units"> | number
    created_at?: DateTimeFilter<"patrol_units"> | Date | string
    category?: Enumpatrol_unit_categoryNullableFilter<"patrol_units"> | $Enums.patrol_unit_category | null
    member_count?: IntNullableFilter<"patrol_units"> | number | null
    updated_at?: DateTimeNullableFilter<"patrol_units"> | Date | string | null
    members?: OfficersListRelationFilter
    location?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
    unit?: XOR<UnitsScalarRelationFilter, unitsWhereInput>
  }, "id" | "id">

  export type patrol_unitsOrderByWithAggregationInput = {
    unit_id?: SortOrder
    location_id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    status?: SortOrder
    radius?: SortOrder
    created_at?: SortOrder
    id?: SortOrder
    category?: SortOrderInput | SortOrder
    member_count?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    _count?: patrol_unitsCountOrderByAggregateInput
    _avg?: patrol_unitsAvgOrderByAggregateInput
    _max?: patrol_unitsMaxOrderByAggregateInput
    _min?: patrol_unitsMinOrderByAggregateInput
    _sum?: patrol_unitsSumOrderByAggregateInput
  }

  export type patrol_unitsScalarWhereWithAggregatesInput = {
    AND?: patrol_unitsScalarWhereWithAggregatesInput | patrol_unitsScalarWhereWithAggregatesInput[]
    OR?: patrol_unitsScalarWhereWithAggregatesInput[]
    NOT?: patrol_unitsScalarWhereWithAggregatesInput | patrol_unitsScalarWhereWithAggregatesInput[]
    unit_id?: StringWithAggregatesFilter<"patrol_units"> | string
    location_id?: UuidWithAggregatesFilter<"patrol_units"> | string
    name?: StringWithAggregatesFilter<"patrol_units"> | string
    type?: StringWithAggregatesFilter<"patrol_units"> | string
    status?: StringWithAggregatesFilter<"patrol_units"> | string
    radius?: FloatWithAggregatesFilter<"patrol_units"> | number
    created_at?: DateTimeWithAggregatesFilter<"patrol_units"> | Date | string
    id?: StringWithAggregatesFilter<"patrol_units"> | string
    category?: Enumpatrol_unit_categoryNullableWithAggregatesFilter<"patrol_units"> | $Enums.patrol_unit_category | null
    member_count?: IntNullableWithAggregatesFilter<"patrol_units"> | number | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"patrol_units"> | Date | string | null
  }

  export type officersWhereInput = {
    AND?: officersWhereInput | officersWhereInput[]
    OR?: officersWhereInput[]
    NOT?: officersWhereInput | officersWhereInput[]
    unit_id?: StringNullableFilter<"officers"> | string | null
    role_id?: UuidFilter<"officers"> | string
    nrp?: StringNullableFilter<"officers"> | string | null
    name?: StringFilter<"officers"> | string
    rank?: StringNullableFilter<"officers"> | string | null
    position?: StringNullableFilter<"officers"> | string | null
    phone?: StringNullableFilter<"officers"> | string | null
    email?: StringNullableFilter<"officers"> | string | null
    avatar?: StringNullableFilter<"officers"> | string | null
    valid_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    qr_code?: StringNullableFilter<"officers"> | string | null
    created_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    patrol_unit_id?: StringNullableFilter<"officers"> | string | null
    id?: UuidFilter<"officers"> | string
    banned_reason?: StringNullableFilter<"officers"> | string | null
    banned_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    is_banned?: BoolFilter<"officers"> | boolean
    panic_strike?: IntFilter<"officers"> | number
    spoofing_attempts?: IntFilter<"officers"> | number
    place_of_birth?: StringNullableFilter<"officers"> | string | null
    date_of_birth?: DateTimeNullableFilter<"officers"> | Date | string | null
    patrol_units?: XOR<Patrol_unitsNullableScalarRelationFilter, patrol_unitsWhereInput> | null
    roles?: XOR<RolesScalarRelationFilter, rolesWhereInput>
    units?: XOR<UnitsNullableScalarRelationFilter, unitsWhereInput> | null
    panic_button_logs?: Panic_button_logsListRelationFilter
    sentMessages?: MessagesListRelationFilter
    receivedMessages?: MessagesListRelationFilter
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }

  export type officersOrderByWithRelationInput = {
    unit_id?: SortOrderInput | SortOrder
    role_id?: SortOrder
    nrp?: SortOrderInput | SortOrder
    name?: SortOrder
    rank?: SortOrderInput | SortOrder
    position?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    avatar?: SortOrderInput | SortOrder
    valid_until?: SortOrderInput | SortOrder
    qr_code?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    patrol_unit_id?: SortOrderInput | SortOrder
    id?: SortOrder
    banned_reason?: SortOrderInput | SortOrder
    banned_until?: SortOrderInput | SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    place_of_birth?: SortOrderInput | SortOrder
    date_of_birth?: SortOrderInput | SortOrder
    patrol_units?: patrol_unitsOrderByWithRelationInput
    roles?: rolesOrderByWithRelationInput
    units?: unitsOrderByWithRelationInput
    panic_button_logs?: panic_button_logsOrderByRelationAggregateInput
    sentMessages?: messagesOrderByRelationAggregateInput
    receivedMessages?: messagesOrderByRelationAggregateInput
    inbox?: inboxOrderByWithRelationInput
  }

  export type officersWhereUniqueInput = Prisma.AtLeast<{
    nrp?: string
    id?: string
    AND?: officersWhereInput | officersWhereInput[]
    OR?: officersWhereInput[]
    NOT?: officersWhereInput | officersWhereInput[]
    unit_id?: StringNullableFilter<"officers"> | string | null
    role_id?: UuidFilter<"officers"> | string
    name?: StringFilter<"officers"> | string
    rank?: StringNullableFilter<"officers"> | string | null
    position?: StringNullableFilter<"officers"> | string | null
    phone?: StringNullableFilter<"officers"> | string | null
    email?: StringNullableFilter<"officers"> | string | null
    avatar?: StringNullableFilter<"officers"> | string | null
    valid_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    qr_code?: StringNullableFilter<"officers"> | string | null
    created_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    patrol_unit_id?: StringNullableFilter<"officers"> | string | null
    banned_reason?: StringNullableFilter<"officers"> | string | null
    banned_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    is_banned?: BoolFilter<"officers"> | boolean
    panic_strike?: IntFilter<"officers"> | number
    spoofing_attempts?: IntFilter<"officers"> | number
    place_of_birth?: StringNullableFilter<"officers"> | string | null
    date_of_birth?: DateTimeNullableFilter<"officers"> | Date | string | null
    patrol_units?: XOR<Patrol_unitsNullableScalarRelationFilter, patrol_unitsWhereInput> | null
    roles?: XOR<RolesScalarRelationFilter, rolesWhereInput>
    units?: XOR<UnitsNullableScalarRelationFilter, unitsWhereInput> | null
    panic_button_logs?: Panic_button_logsListRelationFilter
    sentMessages?: MessagesListRelationFilter
    receivedMessages?: MessagesListRelationFilter
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }, "id" | "nrp">

  export type officersOrderByWithAggregationInput = {
    unit_id?: SortOrderInput | SortOrder
    role_id?: SortOrder
    nrp?: SortOrderInput | SortOrder
    name?: SortOrder
    rank?: SortOrderInput | SortOrder
    position?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    avatar?: SortOrderInput | SortOrder
    valid_until?: SortOrderInput | SortOrder
    qr_code?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    patrol_unit_id?: SortOrderInput | SortOrder
    id?: SortOrder
    banned_reason?: SortOrderInput | SortOrder
    banned_until?: SortOrderInput | SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    place_of_birth?: SortOrderInput | SortOrder
    date_of_birth?: SortOrderInput | SortOrder
    _count?: officersCountOrderByAggregateInput
    _avg?: officersAvgOrderByAggregateInput
    _max?: officersMaxOrderByAggregateInput
    _min?: officersMinOrderByAggregateInput
    _sum?: officersSumOrderByAggregateInput
  }

  export type officersScalarWhereWithAggregatesInput = {
    AND?: officersScalarWhereWithAggregatesInput | officersScalarWhereWithAggregatesInput[]
    OR?: officersScalarWhereWithAggregatesInput[]
    NOT?: officersScalarWhereWithAggregatesInput | officersScalarWhereWithAggregatesInput[]
    unit_id?: StringNullableWithAggregatesFilter<"officers"> | string | null
    role_id?: UuidWithAggregatesFilter<"officers"> | string
    nrp?: StringNullableWithAggregatesFilter<"officers"> | string | null
    name?: StringWithAggregatesFilter<"officers"> | string
    rank?: StringNullableWithAggregatesFilter<"officers"> | string | null
    position?: StringNullableWithAggregatesFilter<"officers"> | string | null
    phone?: StringNullableWithAggregatesFilter<"officers"> | string | null
    email?: StringNullableWithAggregatesFilter<"officers"> | string | null
    avatar?: StringNullableWithAggregatesFilter<"officers"> | string | null
    valid_until?: DateTimeNullableWithAggregatesFilter<"officers"> | Date | string | null
    qr_code?: StringNullableWithAggregatesFilter<"officers"> | string | null
    created_at?: DateTimeNullableWithAggregatesFilter<"officers"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"officers"> | Date | string | null
    patrol_unit_id?: StringNullableWithAggregatesFilter<"officers"> | string | null
    id?: UuidWithAggregatesFilter<"officers"> | string
    banned_reason?: StringNullableWithAggregatesFilter<"officers"> | string | null
    banned_until?: DateTimeNullableWithAggregatesFilter<"officers"> | Date | string | null
    is_banned?: BoolWithAggregatesFilter<"officers"> | boolean
    panic_strike?: IntWithAggregatesFilter<"officers"> | number
    spoofing_attempts?: IntWithAggregatesFilter<"officers"> | number
    place_of_birth?: StringNullableWithAggregatesFilter<"officers"> | string | null
    date_of_birth?: DateTimeNullableWithAggregatesFilter<"officers"> | Date | string | null
  }

  export type unit_statisticsWhereInput = {
    AND?: unit_statisticsWhereInput | unit_statisticsWhereInput[]
    OR?: unit_statisticsWhereInput[]
    NOT?: unit_statisticsWhereInput | unit_statisticsWhereInput[]
    id?: UuidFilter<"unit_statistics"> | string
    crime_total?: IntFilter<"unit_statistics"> | number
    crime_cleared?: IntFilter<"unit_statistics"> | number
    percentage?: FloatNullableFilter<"unit_statistics"> | number | null
    pending?: IntNullableFilter<"unit_statistics"> | number | null
    month?: IntFilter<"unit_statistics"> | number
    year?: IntFilter<"unit_statistics"> | number
    created_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    code_unit?: StringFilter<"unit_statistics"> | string
    units?: XOR<UnitsScalarRelationFilter, unitsWhereInput>
  }

  export type unit_statisticsOrderByWithRelationInput = {
    id?: SortOrder
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrderInput | SortOrder
    pending?: SortOrderInput | SortOrder
    month?: SortOrder
    year?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    code_unit?: SortOrder
    units?: unitsOrderByWithRelationInput
  }

  export type unit_statisticsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    code_unit_month_year?: unit_statisticsCode_unitMonthYearCompoundUniqueInput
    AND?: unit_statisticsWhereInput | unit_statisticsWhereInput[]
    OR?: unit_statisticsWhereInput[]
    NOT?: unit_statisticsWhereInput | unit_statisticsWhereInput[]
    crime_total?: IntFilter<"unit_statistics"> | number
    crime_cleared?: IntFilter<"unit_statistics"> | number
    percentage?: FloatNullableFilter<"unit_statistics"> | number | null
    pending?: IntNullableFilter<"unit_statistics"> | number | null
    month?: IntFilter<"unit_statistics"> | number
    year?: IntFilter<"unit_statistics"> | number
    created_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    code_unit?: StringFilter<"unit_statistics"> | string
    units?: XOR<UnitsScalarRelationFilter, unitsWhereInput>
  }, "id" | "code_unit_month_year">

  export type unit_statisticsOrderByWithAggregationInput = {
    id?: SortOrder
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrderInput | SortOrder
    pending?: SortOrderInput | SortOrder
    month?: SortOrder
    year?: SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    code_unit?: SortOrder
    _count?: unit_statisticsCountOrderByAggregateInput
    _avg?: unit_statisticsAvgOrderByAggregateInput
    _max?: unit_statisticsMaxOrderByAggregateInput
    _min?: unit_statisticsMinOrderByAggregateInput
    _sum?: unit_statisticsSumOrderByAggregateInput
  }

  export type unit_statisticsScalarWhereWithAggregatesInput = {
    AND?: unit_statisticsScalarWhereWithAggregatesInput | unit_statisticsScalarWhereWithAggregatesInput[]
    OR?: unit_statisticsScalarWhereWithAggregatesInput[]
    NOT?: unit_statisticsScalarWhereWithAggregatesInput | unit_statisticsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"unit_statistics"> | string
    crime_total?: IntWithAggregatesFilter<"unit_statistics"> | number
    crime_cleared?: IntWithAggregatesFilter<"unit_statistics"> | number
    percentage?: FloatNullableWithAggregatesFilter<"unit_statistics"> | number | null
    pending?: IntNullableWithAggregatesFilter<"unit_statistics"> | number | null
    month?: IntWithAggregatesFilter<"unit_statistics"> | number
    year?: IntWithAggregatesFilter<"unit_statistics"> | number
    created_at?: DateTimeNullableWithAggregatesFilter<"unit_statistics"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"unit_statistics"> | Date | string | null
    code_unit?: StringWithAggregatesFilter<"unit_statistics"> | string
  }

  export type geographicsWhereInput = {
    AND?: geographicsWhereInput | geographicsWhereInput[]
    OR?: geographicsWhereInput[]
    NOT?: geographicsWhereInput | geographicsWhereInput[]
    id?: UuidFilter<"geographics"> | string
    district_id?: StringFilter<"geographics"> | string
    address?: StringNullableFilter<"geographics"> | string | null
    longitude?: FloatFilter<"geographics"> | number
    latitude?: FloatFilter<"geographics"> | number
    land_area?: FloatNullableFilter<"geographics"> | number | null
    created_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    description?: StringNullableFilter<"geographics"> | string | null
    type?: StringNullableFilter<"geographics"> | string | null
    year?: IntNullableFilter<"geographics"> | number | null
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }

  export type geographicsOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    address?: SortOrderInput | SortOrder
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    year?: SortOrderInput | SortOrder
    districts?: districtsOrderByWithRelationInput
  }

  export type geographicsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: geographicsWhereInput | geographicsWhereInput[]
    OR?: geographicsWhereInput[]
    NOT?: geographicsWhereInput | geographicsWhereInput[]
    district_id?: StringFilter<"geographics"> | string
    address?: StringNullableFilter<"geographics"> | string | null
    longitude?: FloatFilter<"geographics"> | number
    latitude?: FloatFilter<"geographics"> | number
    land_area?: FloatNullableFilter<"geographics"> | number | null
    created_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    description?: StringNullableFilter<"geographics"> | string | null
    type?: StringNullableFilter<"geographics"> | string | null
    year?: IntNullableFilter<"geographics"> | number | null
    districts?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }, "id">

  export type geographicsOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    address?: SortOrderInput | SortOrder
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrderInput | SortOrder
    created_at?: SortOrderInput | SortOrder
    updated_at?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    year?: SortOrderInput | SortOrder
    _count?: geographicsCountOrderByAggregateInput
    _avg?: geographicsAvgOrderByAggregateInput
    _max?: geographicsMaxOrderByAggregateInput
    _min?: geographicsMinOrderByAggregateInput
    _sum?: geographicsSumOrderByAggregateInput
  }

  export type geographicsScalarWhereWithAggregatesInput = {
    AND?: geographicsScalarWhereWithAggregatesInput | geographicsScalarWhereWithAggregatesInput[]
    OR?: geographicsScalarWhereWithAggregatesInput[]
    NOT?: geographicsScalarWhereWithAggregatesInput | geographicsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"geographics"> | string
    district_id?: StringWithAggregatesFilter<"geographics"> | string
    address?: StringNullableWithAggregatesFilter<"geographics"> | string | null
    longitude?: FloatWithAggregatesFilter<"geographics"> | number
    latitude?: FloatWithAggregatesFilter<"geographics"> | number
    land_area?: FloatNullableWithAggregatesFilter<"geographics"> | number | null
    created_at?: DateTimeNullableWithAggregatesFilter<"geographics"> | Date | string | null
    updated_at?: DateTimeNullableWithAggregatesFilter<"geographics"> | Date | string | null
    description?: StringNullableWithAggregatesFilter<"geographics"> | string | null
    type?: StringNullableWithAggregatesFilter<"geographics"> | string | null
    year?: IntNullableWithAggregatesFilter<"geographics"> | number | null
  }

  export type contact_messagesWhereInput = {
    AND?: contact_messagesWhereInput | contact_messagesWhereInput[]
    OR?: contact_messagesWhereInput[]
    NOT?: contact_messagesWhereInput | contact_messagesWhereInput[]
    id?: UuidFilter<"contact_messages"> | string
    name?: StringNullableFilter<"contact_messages"> | string | null
    email?: StringNullableFilter<"contact_messages"> | string | null
    phone?: StringNullableFilter<"contact_messages"> | string | null
    message_type?: StringNullableFilter<"contact_messages"> | string | null
    message_type_label?: StringNullableFilter<"contact_messages"> | string | null
    message?: StringNullableFilter<"contact_messages"> | string | null
    status?: Enumstatus_messagesFilter<"contact_messages"> | $Enums.status_messages
    created_at?: DateTimeFilter<"contact_messages"> | Date | string
    updated_at?: DateTimeFilter<"contact_messages"> | Date | string
  }

  export type contact_messagesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    message_type?: SortOrderInput | SortOrder
    message_type_label?: SortOrderInput | SortOrder
    message?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type contact_messagesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: contact_messagesWhereInput | contact_messagesWhereInput[]
    OR?: contact_messagesWhereInput[]
    NOT?: contact_messagesWhereInput | contact_messagesWhereInput[]
    name?: StringNullableFilter<"contact_messages"> | string | null
    email?: StringNullableFilter<"contact_messages"> | string | null
    phone?: StringNullableFilter<"contact_messages"> | string | null
    message_type?: StringNullableFilter<"contact_messages"> | string | null
    message_type_label?: StringNullableFilter<"contact_messages"> | string | null
    message?: StringNullableFilter<"contact_messages"> | string | null
    status?: Enumstatus_messagesFilter<"contact_messages"> | $Enums.status_messages
    created_at?: DateTimeFilter<"contact_messages"> | Date | string
    updated_at?: DateTimeFilter<"contact_messages"> | Date | string
  }, "id">

  export type contact_messagesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    message_type?: SortOrderInput | SortOrder
    message_type_label?: SortOrderInput | SortOrder
    message?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: contact_messagesCountOrderByAggregateInput
    _max?: contact_messagesMaxOrderByAggregateInput
    _min?: contact_messagesMinOrderByAggregateInput
  }

  export type contact_messagesScalarWhereWithAggregatesInput = {
    AND?: contact_messagesScalarWhereWithAggregatesInput | contact_messagesScalarWhereWithAggregatesInput[]
    OR?: contact_messagesScalarWhereWithAggregatesInput[]
    NOT?: contact_messagesScalarWhereWithAggregatesInput | contact_messagesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"contact_messages"> | string
    name?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    email?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    phone?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    message_type?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    message_type_label?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    message?: StringNullableWithAggregatesFilter<"contact_messages"> | string | null
    status?: Enumstatus_messagesWithAggregatesFilter<"contact_messages"> | $Enums.status_messages
    created_at?: DateTimeWithAggregatesFilter<"contact_messages"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"contact_messages"> | Date | string
  }

  export type messagesWhereInput = {
    AND?: messagesWhereInput | messagesWhereInput[]
    OR?: messagesWhereInput[]
    NOT?: messagesWhereInput | messagesWhereInput[]
    id?: UuidFilter<"messages"> | string
    subject?: StringFilter<"messages"> | string
    content?: StringFilter<"messages"> | string
    message_type?: StringNullableFilter<"messages"> | string | null
    message_type_label?: StringNullableFilter<"messages"> | string | null
    sender_user_id?: UuidNullableFilter<"messages"> | string | null
    sender_officer_id?: UuidNullableFilter<"messages"> | string | null
    recipient_user_id?: UuidNullableFilter<"messages"> | string | null
    recipient_officer_id?: UuidNullableFilter<"messages"> | string | null
    inbox_id?: UuidNullableFilter<"messages"> | string | null
    status?: Enumstatus_messagesFilter<"messages"> | $Enums.status_messages
    created_at?: DateTimeFilter<"messages"> | Date | string
    updated_at?: DateTimeFilter<"messages"> | Date | string
    file_url?: StringNullableFilter<"messages"> | string | null
    file_type?: StringNullableFilter<"messages"> | string | null
    file_name?: StringNullableFilter<"messages"> | string | null
    is_starred?: BoolFilter<"messages"> | boolean
    sender_user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
    sender_officer?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    recipient_user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
    recipient_officer?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }

  export type messagesOrderByWithRelationInput = {
    id?: SortOrder
    subject?: SortOrder
    content?: SortOrder
    message_type?: SortOrderInput | SortOrder
    message_type_label?: SortOrderInput | SortOrder
    sender_user_id?: SortOrderInput | SortOrder
    sender_officer_id?: SortOrderInput | SortOrder
    recipient_user_id?: SortOrderInput | SortOrder
    recipient_officer_id?: SortOrderInput | SortOrder
    inbox_id?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    file_url?: SortOrderInput | SortOrder
    file_type?: SortOrderInput | SortOrder
    file_name?: SortOrderInput | SortOrder
    is_starred?: SortOrder
    sender_user?: usersOrderByWithRelationInput
    sender_officer?: officersOrderByWithRelationInput
    recipient_user?: usersOrderByWithRelationInput
    recipient_officer?: officersOrderByWithRelationInput
    inbox?: inboxOrderByWithRelationInput
  }

  export type messagesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: messagesWhereInput | messagesWhereInput[]
    OR?: messagesWhereInput[]
    NOT?: messagesWhereInput | messagesWhereInput[]
    subject?: StringFilter<"messages"> | string
    content?: StringFilter<"messages"> | string
    message_type?: StringNullableFilter<"messages"> | string | null
    message_type_label?: StringNullableFilter<"messages"> | string | null
    sender_user_id?: UuidNullableFilter<"messages"> | string | null
    sender_officer_id?: UuidNullableFilter<"messages"> | string | null
    recipient_user_id?: UuidNullableFilter<"messages"> | string | null
    recipient_officer_id?: UuidNullableFilter<"messages"> | string | null
    inbox_id?: UuidNullableFilter<"messages"> | string | null
    status?: Enumstatus_messagesFilter<"messages"> | $Enums.status_messages
    created_at?: DateTimeFilter<"messages"> | Date | string
    updated_at?: DateTimeFilter<"messages"> | Date | string
    file_url?: StringNullableFilter<"messages"> | string | null
    file_type?: StringNullableFilter<"messages"> | string | null
    file_name?: StringNullableFilter<"messages"> | string | null
    is_starred?: BoolFilter<"messages"> | boolean
    sender_user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
    sender_officer?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    recipient_user?: XOR<UsersNullableScalarRelationFilter, usersWhereInput> | null
    recipient_officer?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    inbox?: XOR<InboxNullableScalarRelationFilter, inboxWhereInput> | null
  }, "id">

  export type messagesOrderByWithAggregationInput = {
    id?: SortOrder
    subject?: SortOrder
    content?: SortOrder
    message_type?: SortOrderInput | SortOrder
    message_type_label?: SortOrderInput | SortOrder
    sender_user_id?: SortOrderInput | SortOrder
    sender_officer_id?: SortOrderInput | SortOrder
    recipient_user_id?: SortOrderInput | SortOrder
    recipient_officer_id?: SortOrderInput | SortOrder
    inbox_id?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    file_url?: SortOrderInput | SortOrder
    file_type?: SortOrderInput | SortOrder
    file_name?: SortOrderInput | SortOrder
    is_starred?: SortOrder
    _count?: messagesCountOrderByAggregateInput
    _max?: messagesMaxOrderByAggregateInput
    _min?: messagesMinOrderByAggregateInput
  }

  export type messagesScalarWhereWithAggregatesInput = {
    AND?: messagesScalarWhereWithAggregatesInput | messagesScalarWhereWithAggregatesInput[]
    OR?: messagesScalarWhereWithAggregatesInput[]
    NOT?: messagesScalarWhereWithAggregatesInput | messagesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"messages"> | string
    subject?: StringWithAggregatesFilter<"messages"> | string
    content?: StringWithAggregatesFilter<"messages"> | string
    message_type?: StringNullableWithAggregatesFilter<"messages"> | string | null
    message_type_label?: StringNullableWithAggregatesFilter<"messages"> | string | null
    sender_user_id?: UuidNullableWithAggregatesFilter<"messages"> | string | null
    sender_officer_id?: UuidNullableWithAggregatesFilter<"messages"> | string | null
    recipient_user_id?: UuidNullableWithAggregatesFilter<"messages"> | string | null
    recipient_officer_id?: UuidNullableWithAggregatesFilter<"messages"> | string | null
    inbox_id?: UuidNullableWithAggregatesFilter<"messages"> | string | null
    status?: Enumstatus_messagesWithAggregatesFilter<"messages"> | $Enums.status_messages
    created_at?: DateTimeWithAggregatesFilter<"messages"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"messages"> | Date | string
    file_url?: StringNullableWithAggregatesFilter<"messages"> | string | null
    file_type?: StringNullableWithAggregatesFilter<"messages"> | string | null
    file_name?: StringNullableWithAggregatesFilter<"messages"> | string | null
    is_starred?: BoolWithAggregatesFilter<"messages"> | boolean
  }

  export type inboxWhereInput = {
    AND?: inboxWhereInput | inboxWhereInput[]
    OR?: inboxWhereInput[]
    NOT?: inboxWhereInput | inboxWhereInput[]
    id?: UuidFilter<"inbox"> | string
    user_id?: UuidFilter<"inbox"> | string
    officer_id?: UuidFilter<"inbox"> | string
    unread_count?: IntFilter<"inbox"> | number
    last_updated?: DateTimeFilter<"inbox"> | Date | string
    created_at?: DateTimeFilter<"inbox"> | Date | string
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
    officer?: XOR<OfficersScalarRelationFilter, officersWhereInput>
    messages?: MessagesListRelationFilter
  }

  export type inboxOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    unread_count?: SortOrder
    last_updated?: SortOrder
    created_at?: SortOrder
    user?: usersOrderByWithRelationInput
    officer?: officersOrderByWithRelationInput
    messages?: messagesOrderByRelationAggregateInput
  }

  export type inboxWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    user_id?: string
    officer_id?: string
    AND?: inboxWhereInput | inboxWhereInput[]
    OR?: inboxWhereInput[]
    NOT?: inboxWhereInput | inboxWhereInput[]
    unread_count?: IntFilter<"inbox"> | number
    last_updated?: DateTimeFilter<"inbox"> | Date | string
    created_at?: DateTimeFilter<"inbox"> | Date | string
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
    officer?: XOR<OfficersScalarRelationFilter, officersWhereInput>
    messages?: MessagesListRelationFilter
  }, "id" | "user_id" | "officer_id">

  export type inboxOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    unread_count?: SortOrder
    last_updated?: SortOrder
    created_at?: SortOrder
    _count?: inboxCountOrderByAggregateInput
    _avg?: inboxAvgOrderByAggregateInput
    _max?: inboxMaxOrderByAggregateInput
    _min?: inboxMinOrderByAggregateInput
    _sum?: inboxSumOrderByAggregateInput
  }

  export type inboxScalarWhereWithAggregatesInput = {
    AND?: inboxScalarWhereWithAggregatesInput | inboxScalarWhereWithAggregatesInput[]
    OR?: inboxScalarWhereWithAggregatesInput[]
    NOT?: inboxScalarWhereWithAggregatesInput | inboxScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"inbox"> | string
    user_id?: UuidWithAggregatesFilter<"inbox"> | string
    officer_id?: UuidWithAggregatesFilter<"inbox"> | string
    unread_count?: IntWithAggregatesFilter<"inbox"> | number
    last_updated?: DateTimeWithAggregatesFilter<"inbox"> | Date | string
    created_at?: DateTimeWithAggregatesFilter<"inbox"> | Date | string
  }

  export type logsWhereInput = {
    AND?: logsWhereInput | logsWhereInput[]
    OR?: logsWhereInput[]
    NOT?: logsWhereInput | logsWhereInput[]
    id?: UuidFilter<"logs"> | string
    action?: StringFilter<"logs"> | string
    entity?: StringFilter<"logs"> | string
    entity_id?: StringNullableFilter<"logs"> | string | null
    changes?: JsonNullableFilter<"logs">
    user_id?: StringNullableFilter<"logs"> | string | null
    ip_address?: StringNullableFilter<"logs"> | string | null
    user_agent?: StringNullableFilter<"logs"> | string | null
    created_at?: DateTimeFilter<"logs"> | Date | string
  }

  export type logsOrderByWithRelationInput = {
    id?: SortOrder
    action?: SortOrder
    entity?: SortOrder
    entity_id?: SortOrderInput | SortOrder
    changes?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    ip_address?: SortOrderInput | SortOrder
    user_agent?: SortOrderInput | SortOrder
    created_at?: SortOrder
  }

  export type logsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: logsWhereInput | logsWhereInput[]
    OR?: logsWhereInput[]
    NOT?: logsWhereInput | logsWhereInput[]
    action?: StringFilter<"logs"> | string
    entity?: StringFilter<"logs"> | string
    entity_id?: StringNullableFilter<"logs"> | string | null
    changes?: JsonNullableFilter<"logs">
    user_id?: StringNullableFilter<"logs"> | string | null
    ip_address?: StringNullableFilter<"logs"> | string | null
    user_agent?: StringNullableFilter<"logs"> | string | null
    created_at?: DateTimeFilter<"logs"> | Date | string
  }, "id">

  export type logsOrderByWithAggregationInput = {
    id?: SortOrder
    action?: SortOrder
    entity?: SortOrder
    entity_id?: SortOrderInput | SortOrder
    changes?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    ip_address?: SortOrderInput | SortOrder
    user_agent?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: logsCountOrderByAggregateInput
    _max?: logsMaxOrderByAggregateInput
    _min?: logsMinOrderByAggregateInput
  }

  export type logsScalarWhereWithAggregatesInput = {
    AND?: logsScalarWhereWithAggregatesInput | logsScalarWhereWithAggregatesInput[]
    OR?: logsScalarWhereWithAggregatesInput[]
    NOT?: logsScalarWhereWithAggregatesInput | logsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"logs"> | string
    action?: StringWithAggregatesFilter<"logs"> | string
    entity?: StringWithAggregatesFilter<"logs"> | string
    entity_id?: StringNullableWithAggregatesFilter<"logs"> | string | null
    changes?: JsonNullableWithAggregatesFilter<"logs">
    user_id?: StringNullableWithAggregatesFilter<"logs"> | string | null
    ip_address?: StringNullableWithAggregatesFilter<"logs"> | string | null
    user_agent?: StringNullableWithAggregatesFilter<"logs"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"logs"> | Date | string
  }

  export type panic_button_logsWhereInput = {
    AND?: panic_button_logsWhereInput | panic_button_logsWhereInput[]
    OR?: panic_button_logsWhereInput[]
    NOT?: panic_button_logsWhereInput | panic_button_logsWhereInput[]
    id?: UuidFilter<"panic_button_logs"> | string
    user_id?: UuidFilter<"panic_button_logs"> | string
    officer_id?: UuidNullableFilter<"panic_button_logs"> | string | null
    incident_logs_id?: UuidFilter<"panic_button_logs"> | string
    timestamp?: DateTimeFilter<"panic_button_logs"> | Date | string
    incidents?: XOR<Incident_logsScalarRelationFilter, incident_logsWhereInput>
    officers?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }

  export type panic_button_logsOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrderInput | SortOrder
    incident_logs_id?: SortOrder
    timestamp?: SortOrder
    incidents?: incident_logsOrderByWithRelationInput
    officers?: officersOrderByWithRelationInput
    users?: usersOrderByWithRelationInput
  }

  export type panic_button_logsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: panic_button_logsWhereInput | panic_button_logsWhereInput[]
    OR?: panic_button_logsWhereInput[]
    NOT?: panic_button_logsWhereInput | panic_button_logsWhereInput[]
    user_id?: UuidFilter<"panic_button_logs"> | string
    officer_id?: UuidNullableFilter<"panic_button_logs"> | string | null
    incident_logs_id?: UuidFilter<"panic_button_logs"> | string
    timestamp?: DateTimeFilter<"panic_button_logs"> | Date | string
    incidents?: XOR<Incident_logsScalarRelationFilter, incident_logsWhereInput>
    officers?: XOR<OfficersNullableScalarRelationFilter, officersWhereInput> | null
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }, "id">

  export type panic_button_logsOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrderInput | SortOrder
    incident_logs_id?: SortOrder
    timestamp?: SortOrder
    _count?: panic_button_logsCountOrderByAggregateInput
    _max?: panic_button_logsMaxOrderByAggregateInput
    _min?: panic_button_logsMinOrderByAggregateInput
  }

  export type panic_button_logsScalarWhereWithAggregatesInput = {
    AND?: panic_button_logsScalarWhereWithAggregatesInput | panic_button_logsScalarWhereWithAggregatesInput[]
    OR?: panic_button_logsScalarWhereWithAggregatesInput[]
    NOT?: panic_button_logsScalarWhereWithAggregatesInput | panic_button_logsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"panic_button_logs"> | string
    user_id?: UuidWithAggregatesFilter<"panic_button_logs"> | string
    officer_id?: UuidNullableWithAggregatesFilter<"panic_button_logs"> | string | null
    incident_logs_id?: UuidWithAggregatesFilter<"panic_button_logs"> | string
    timestamp?: DateTimeWithAggregatesFilter<"panic_button_logs"> | Date | string
  }

  export type location_logsWhereInput = {
    AND?: location_logsWhereInput | location_logsWhereInput[]
    OR?: location_logsWhereInput[]
    NOT?: location_logsWhereInput | location_logsWhereInput[]
    id?: UuidFilter<"location_logs"> | string
    location_id?: UuidFilter<"location_logs"> | string
    latitude?: FloatFilter<"location_logs"> | number
    longitude?: FloatFilter<"location_logs"> | number
    timestamp?: DateTimeFilter<"location_logs"> | Date | string
    description?: StringNullableFilter<"location_logs"> | string | null
    created_at?: DateTimeFilter<"location_logs"> | Date | string
    updated_at?: DateTimeFilter<"location_logs"> | Date | string
    location?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
  }

  export type location_logsOrderByWithRelationInput = {
    id?: SortOrder
    location_id?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    timestamp?: SortOrder
    description?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    location?: locationsOrderByWithRelationInput
  }

  export type location_logsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: location_logsWhereInput | location_logsWhereInput[]
    OR?: location_logsWhereInput[]
    NOT?: location_logsWhereInput | location_logsWhereInput[]
    location_id?: UuidFilter<"location_logs"> | string
    latitude?: FloatFilter<"location_logs"> | number
    longitude?: FloatFilter<"location_logs"> | number
    timestamp?: DateTimeFilter<"location_logs"> | Date | string
    description?: StringNullableFilter<"location_logs"> | string | null
    created_at?: DateTimeFilter<"location_logs"> | Date | string
    updated_at?: DateTimeFilter<"location_logs"> | Date | string
    location?: XOR<LocationsScalarRelationFilter, locationsWhereInput>
  }, "id">

  export type location_logsOrderByWithAggregationInput = {
    id?: SortOrder
    location_id?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    timestamp?: SortOrder
    description?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: location_logsCountOrderByAggregateInput
    _avg?: location_logsAvgOrderByAggregateInput
    _max?: location_logsMaxOrderByAggregateInput
    _min?: location_logsMinOrderByAggregateInput
    _sum?: location_logsSumOrderByAggregateInput
  }

  export type location_logsScalarWhereWithAggregatesInput = {
    AND?: location_logsScalarWhereWithAggregatesInput | location_logsScalarWhereWithAggregatesInput[]
    OR?: location_logsScalarWhereWithAggregatesInput[]
    NOT?: location_logsScalarWhereWithAggregatesInput | location_logsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"location_logs"> | string
    location_id?: UuidWithAggregatesFilter<"location_logs"> | string
    latitude?: FloatWithAggregatesFilter<"location_logs"> | number
    longitude?: FloatWithAggregatesFilter<"location_logs"> | number
    timestamp?: DateTimeWithAggregatesFilter<"location_logs"> | Date | string
    description?: StringNullableWithAggregatesFilter<"location_logs"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"location_logs"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"location_logs"> | Date | string
  }

  export type district_clustersWhereInput = {
    AND?: district_clustersWhereInput | district_clustersWhereInput[]
    OR?: district_clustersWhereInput[]
    NOT?: district_clustersWhereInput | district_clustersWhereInput[]
    id?: UuidFilter<"district_clusters"> | string
    district_id?: StringFilter<"district_clusters"> | string
    year?: IntFilter<"district_clusters"> | number
    month?: IntNullableFilter<"district_clusters"> | number | null
    risk_level?: Enumcrime_ratesFilter<"district_clusters"> | $Enums.crime_rates
    total_crimes?: IntFilter<"district_clusters"> | number
    population_density?: FloatFilter<"district_clusters"> | number
    unemployment_rate?: FloatFilter<"district_clusters"> | number
    crime_score?: FloatFilter<"district_clusters"> | number
    density_score?: FloatFilter<"district_clusters"> | number
    unemployment_score?: FloatFilter<"district_clusters"> | number
    cluster_score?: FloatFilter<"district_clusters"> | number
    centroid_features?: JsonNullableFilter<"district_clusters">
    member_count?: IntFilter<"district_clusters"> | number
    last_update_type?: StringFilter<"district_clusters"> | string
    update_count?: IntFilter<"district_clusters"> | number
    needs_recompute?: BoolFilter<"district_clusters"> | boolean
    incidents_data?: JsonNullableFilter<"district_clusters">
    created_at?: DateTimeFilter<"district_clusters"> | Date | string
    updated_at?: DateTimeFilter<"district_clusters"> | Date | string
    district?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }

  export type district_clustersOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    year?: SortOrder
    month?: SortOrderInput | SortOrder
    risk_level?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    centroid_features?: SortOrderInput | SortOrder
    member_count?: SortOrder
    last_update_type?: SortOrder
    update_count?: SortOrder
    needs_recompute?: SortOrder
    incidents_data?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    district?: districtsOrderByWithRelationInput
  }

  export type district_clustersWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    district_id_year_month?: district_clustersDistrict_idYearMonthCompoundUniqueInput
    AND?: district_clustersWhereInput | district_clustersWhereInput[]
    OR?: district_clustersWhereInput[]
    NOT?: district_clustersWhereInput | district_clustersWhereInput[]
    district_id?: StringFilter<"district_clusters"> | string
    year?: IntFilter<"district_clusters"> | number
    month?: IntNullableFilter<"district_clusters"> | number | null
    risk_level?: Enumcrime_ratesFilter<"district_clusters"> | $Enums.crime_rates
    total_crimes?: IntFilter<"district_clusters"> | number
    population_density?: FloatFilter<"district_clusters"> | number
    unemployment_rate?: FloatFilter<"district_clusters"> | number
    crime_score?: FloatFilter<"district_clusters"> | number
    density_score?: FloatFilter<"district_clusters"> | number
    unemployment_score?: FloatFilter<"district_clusters"> | number
    cluster_score?: FloatFilter<"district_clusters"> | number
    centroid_features?: JsonNullableFilter<"district_clusters">
    member_count?: IntFilter<"district_clusters"> | number
    last_update_type?: StringFilter<"district_clusters"> | string
    update_count?: IntFilter<"district_clusters"> | number
    needs_recompute?: BoolFilter<"district_clusters"> | boolean
    incidents_data?: JsonNullableFilter<"district_clusters">
    created_at?: DateTimeFilter<"district_clusters"> | Date | string
    updated_at?: DateTimeFilter<"district_clusters"> | Date | string
    district?: XOR<DistrictsScalarRelationFilter, districtsWhereInput>
  }, "id" | "district_id_year_month">

  export type district_clustersOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    year?: SortOrder
    month?: SortOrderInput | SortOrder
    risk_level?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    centroid_features?: SortOrderInput | SortOrder
    member_count?: SortOrder
    last_update_type?: SortOrder
    update_count?: SortOrder
    needs_recompute?: SortOrder
    incidents_data?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: district_clustersCountOrderByAggregateInput
    _avg?: district_clustersAvgOrderByAggregateInput
    _max?: district_clustersMaxOrderByAggregateInput
    _min?: district_clustersMinOrderByAggregateInput
    _sum?: district_clustersSumOrderByAggregateInput
  }

  export type district_clustersScalarWhereWithAggregatesInput = {
    AND?: district_clustersScalarWhereWithAggregatesInput | district_clustersScalarWhereWithAggregatesInput[]
    OR?: district_clustersScalarWhereWithAggregatesInput[]
    NOT?: district_clustersScalarWhereWithAggregatesInput | district_clustersScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"district_clusters"> | string
    district_id?: StringWithAggregatesFilter<"district_clusters"> | string
    year?: IntWithAggregatesFilter<"district_clusters"> | number
    month?: IntNullableWithAggregatesFilter<"district_clusters"> | number | null
    risk_level?: Enumcrime_ratesWithAggregatesFilter<"district_clusters"> | $Enums.crime_rates
    total_crimes?: IntWithAggregatesFilter<"district_clusters"> | number
    population_density?: FloatWithAggregatesFilter<"district_clusters"> | number
    unemployment_rate?: FloatWithAggregatesFilter<"district_clusters"> | number
    crime_score?: FloatWithAggregatesFilter<"district_clusters"> | number
    density_score?: FloatWithAggregatesFilter<"district_clusters"> | number
    unemployment_score?: FloatWithAggregatesFilter<"district_clusters"> | number
    cluster_score?: FloatWithAggregatesFilter<"district_clusters"> | number
    centroid_features?: JsonNullableWithAggregatesFilter<"district_clusters">
    member_count?: IntWithAggregatesFilter<"district_clusters"> | number
    last_update_type?: StringWithAggregatesFilter<"district_clusters"> | string
    update_count?: IntWithAggregatesFilter<"district_clusters"> | number
    needs_recompute?: BoolWithAggregatesFilter<"district_clusters"> | boolean
    incidents_data?: JsonNullableWithAggregatesFilter<"district_clusters">
    created_at?: DateTimeWithAggregatesFilter<"district_clusters"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"district_clusters"> | Date | string
  }

  export type cluster_updatesWhereInput = {
    AND?: cluster_updatesWhereInput | cluster_updatesWhereInput[]
    OR?: cluster_updatesWhereInput[]
    NOT?: cluster_updatesWhereInput | cluster_updatesWhereInput[]
    id?: UuidFilter<"cluster_updates"> | string
    district_id?: StringFilter<"cluster_updates"> | string
    update_type?: StringFilter<"cluster_updates"> | string
    old_value?: JsonNullableFilter<"cluster_updates">
    new_value?: JsonNullableFilter<"cluster_updates">
    processed?: BoolFilter<"cluster_updates"> | boolean
    timestamp?: DateTimeFilter<"cluster_updates"> | Date | string
  }

  export type cluster_updatesOrderByWithRelationInput = {
    id?: SortOrder
    district_id?: SortOrder
    update_type?: SortOrder
    old_value?: SortOrderInput | SortOrder
    new_value?: SortOrderInput | SortOrder
    processed?: SortOrder
    timestamp?: SortOrder
  }

  export type cluster_updatesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: cluster_updatesWhereInput | cluster_updatesWhereInput[]
    OR?: cluster_updatesWhereInput[]
    NOT?: cluster_updatesWhereInput | cluster_updatesWhereInput[]
    district_id?: StringFilter<"cluster_updates"> | string
    update_type?: StringFilter<"cluster_updates"> | string
    old_value?: JsonNullableFilter<"cluster_updates">
    new_value?: JsonNullableFilter<"cluster_updates">
    processed?: BoolFilter<"cluster_updates"> | boolean
    timestamp?: DateTimeFilter<"cluster_updates"> | Date | string
  }, "id">

  export type cluster_updatesOrderByWithAggregationInput = {
    id?: SortOrder
    district_id?: SortOrder
    update_type?: SortOrder
    old_value?: SortOrderInput | SortOrder
    new_value?: SortOrderInput | SortOrder
    processed?: SortOrder
    timestamp?: SortOrder
    _count?: cluster_updatesCountOrderByAggregateInput
    _max?: cluster_updatesMaxOrderByAggregateInput
    _min?: cluster_updatesMinOrderByAggregateInput
  }

  export type cluster_updatesScalarWhereWithAggregatesInput = {
    AND?: cluster_updatesScalarWhereWithAggregatesInput | cluster_updatesScalarWhereWithAggregatesInput[]
    OR?: cluster_updatesScalarWhereWithAggregatesInput[]
    NOT?: cluster_updatesScalarWhereWithAggregatesInput | cluster_updatesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"cluster_updates"> | string
    district_id?: StringWithAggregatesFilter<"cluster_updates"> | string
    update_type?: StringWithAggregatesFilter<"cluster_updates"> | string
    old_value?: JsonNullableWithAggregatesFilter<"cluster_updates">
    new_value?: JsonNullableWithAggregatesFilter<"cluster_updates">
    processed?: BoolWithAggregatesFilter<"cluster_updates"> | boolean
    timestamp?: DateTimeWithAggregatesFilter<"cluster_updates"> | Date | string
  }

  export type taskWhereInput = {
    AND?: taskWhereInput | taskWhereInput[]
    OR?: taskWhereInput[]
    NOT?: taskWhereInput | taskWhereInput[]
    id?: UuidFilter<"task"> | string
    user_id?: UuidFilter<"task"> | string
    code?: StringFilter<"task"> | string
    title?: StringNullableFilter<"task"> | string | null
    status?: Enumtask_statusFilter<"task"> | $Enums.task_status
    label?: Enumtask_labelFilter<"task"> | $Enums.task_label
    priority?: Enumtask_priorityFilter<"task"> | $Enums.task_priority
    estimated_hours?: FloatFilter<"task"> | number
    archived?: BoolFilter<"task"> | boolean
    created_at?: DateTimeFilter<"task"> | Date | string
    updated_at?: DateTimeFilter<"task"> | Date | string
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }

  export type taskOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    code?: SortOrder
    title?: SortOrderInput | SortOrder
    status?: SortOrder
    label?: SortOrder
    priority?: SortOrder
    estimated_hours?: SortOrder
    archived?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    user?: usersOrderByWithRelationInput
  }

  export type taskWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    code?: string
    AND?: taskWhereInput | taskWhereInput[]
    OR?: taskWhereInput[]
    NOT?: taskWhereInput | taskWhereInput[]
    user_id?: UuidFilter<"task"> | string
    title?: StringNullableFilter<"task"> | string | null
    status?: Enumtask_statusFilter<"task"> | $Enums.task_status
    label?: Enumtask_labelFilter<"task"> | $Enums.task_label
    priority?: Enumtask_priorityFilter<"task"> | $Enums.task_priority
    estimated_hours?: FloatFilter<"task"> | number
    archived?: BoolFilter<"task"> | boolean
    created_at?: DateTimeFilter<"task"> | Date | string
    updated_at?: DateTimeFilter<"task"> | Date | string
    user?: XOR<UsersScalarRelationFilter, usersWhereInput>
  }, "id" | "code">

  export type taskOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    code?: SortOrder
    title?: SortOrderInput | SortOrder
    status?: SortOrder
    label?: SortOrder
    priority?: SortOrder
    estimated_hours?: SortOrder
    archived?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: taskCountOrderByAggregateInput
    _avg?: taskAvgOrderByAggregateInput
    _max?: taskMaxOrderByAggregateInput
    _min?: taskMinOrderByAggregateInput
    _sum?: taskSumOrderByAggregateInput
  }

  export type taskScalarWhereWithAggregatesInput = {
    AND?: taskScalarWhereWithAggregatesInput | taskScalarWhereWithAggregatesInput[]
    OR?: taskScalarWhereWithAggregatesInput[]
    NOT?: taskScalarWhereWithAggregatesInput | taskScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"task"> | string
    user_id?: UuidWithAggregatesFilter<"task"> | string
    code?: StringWithAggregatesFilter<"task"> | string
    title?: StringNullableWithAggregatesFilter<"task"> | string | null
    status?: Enumtask_statusWithAggregatesFilter<"task"> | $Enums.task_status
    label?: Enumtask_labelWithAggregatesFilter<"task"> | $Enums.task_label
    priority?: Enumtask_priorityWithAggregatesFilter<"task"> | $Enums.task_priority
    estimated_hours?: FloatWithAggregatesFilter<"task"> | number
    archived?: BoolWithAggregatesFilter<"task"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"task"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"task"> | Date | string
  }

  export type projectsWhereInput = {
    AND?: projectsWhereInput | projectsWhereInput[]
    OR?: projectsWhereInput[]
    NOT?: projectsWhereInput | projectsWhereInput[]
    id?: UuidFilter<"projects"> | string
    name?: StringFilter<"projects"> | string
    description?: StringNullableFilter<"projects"> | string | null
    user_id?: UuidFilter<"projects"> | string
    created_at?: DateTimeFilter<"projects"> | Date | string
    updated_at?: DateTimeFilter<"projects"> | Date | string
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
    datasets?: DatasetsListRelationFilter
    analyses?: AnalysesListRelationFilter
  }

  export type projectsOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    users?: usersOrderByWithRelationInput
    datasets?: datasetsOrderByRelationAggregateInput
    analyses?: analysesOrderByRelationAggregateInput
  }

  export type projectsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: projectsWhereInput | projectsWhereInput[]
    OR?: projectsWhereInput[]
    NOT?: projectsWhereInput | projectsWhereInput[]
    name?: StringFilter<"projects"> | string
    description?: StringNullableFilter<"projects"> | string | null
    user_id?: UuidFilter<"projects"> | string
    created_at?: DateTimeFilter<"projects"> | Date | string
    updated_at?: DateTimeFilter<"projects"> | Date | string
    users?: XOR<UsersScalarRelationFilter, usersWhereInput>
    datasets?: DatasetsListRelationFilter
    analyses?: AnalysesListRelationFilter
  }, "id">

  export type projectsOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: projectsCountOrderByAggregateInput
    _max?: projectsMaxOrderByAggregateInput
    _min?: projectsMinOrderByAggregateInput
  }

  export type projectsScalarWhereWithAggregatesInput = {
    AND?: projectsScalarWhereWithAggregatesInput | projectsScalarWhereWithAggregatesInput[]
    OR?: projectsScalarWhereWithAggregatesInput[]
    NOT?: projectsScalarWhereWithAggregatesInput | projectsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"projects"> | string
    name?: StringWithAggregatesFilter<"projects"> | string
    description?: StringNullableWithAggregatesFilter<"projects"> | string | null
    user_id?: UuidWithAggregatesFilter<"projects"> | string
    created_at?: DateTimeWithAggregatesFilter<"projects"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"projects"> | Date | string
  }

  export type datasetsWhereInput = {
    AND?: datasetsWhereInput | datasetsWhereInput[]
    OR?: datasetsWhereInput[]
    NOT?: datasetsWhereInput | datasetsWhereInput[]
    id?: UuidFilter<"datasets"> | string
    project_id?: UuidFilter<"datasets"> | string
    filename?: StringFilter<"datasets"> | string
    original_name?: StringFilter<"datasets"> | string
    file_size?: IntFilter<"datasets"> | number
    columns?: JsonFilter<"datasets">
    row_count?: IntFilter<"datasets"> | number
    metadata?: JsonNullableFilter<"datasets">
    created_at?: DateTimeFilter<"datasets"> | Date | string
    projects?: XOR<ProjectsScalarRelationFilter, projectsWhereInput>
    analyses?: AnalysesListRelationFilter
  }

  export type datasetsOrderByWithRelationInput = {
    id?: SortOrder
    project_id?: SortOrder
    filename?: SortOrder
    original_name?: SortOrder
    file_size?: SortOrder
    columns?: SortOrder
    row_count?: SortOrder
    metadata?: SortOrderInput | SortOrder
    created_at?: SortOrder
    projects?: projectsOrderByWithRelationInput
    analyses?: analysesOrderByRelationAggregateInput
  }

  export type datasetsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: datasetsWhereInput | datasetsWhereInput[]
    OR?: datasetsWhereInput[]
    NOT?: datasetsWhereInput | datasetsWhereInput[]
    project_id?: UuidFilter<"datasets"> | string
    filename?: StringFilter<"datasets"> | string
    original_name?: StringFilter<"datasets"> | string
    file_size?: IntFilter<"datasets"> | number
    columns?: JsonFilter<"datasets">
    row_count?: IntFilter<"datasets"> | number
    metadata?: JsonNullableFilter<"datasets">
    created_at?: DateTimeFilter<"datasets"> | Date | string
    projects?: XOR<ProjectsScalarRelationFilter, projectsWhereInput>
    analyses?: AnalysesListRelationFilter
  }, "id">

  export type datasetsOrderByWithAggregationInput = {
    id?: SortOrder
    project_id?: SortOrder
    filename?: SortOrder
    original_name?: SortOrder
    file_size?: SortOrder
    columns?: SortOrder
    row_count?: SortOrder
    metadata?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: datasetsCountOrderByAggregateInput
    _avg?: datasetsAvgOrderByAggregateInput
    _max?: datasetsMaxOrderByAggregateInput
    _min?: datasetsMinOrderByAggregateInput
    _sum?: datasetsSumOrderByAggregateInput
  }

  export type datasetsScalarWhereWithAggregatesInput = {
    AND?: datasetsScalarWhereWithAggregatesInput | datasetsScalarWhereWithAggregatesInput[]
    OR?: datasetsScalarWhereWithAggregatesInput[]
    NOT?: datasetsScalarWhereWithAggregatesInput | datasetsScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"datasets"> | string
    project_id?: UuidWithAggregatesFilter<"datasets"> | string
    filename?: StringWithAggregatesFilter<"datasets"> | string
    original_name?: StringWithAggregatesFilter<"datasets"> | string
    file_size?: IntWithAggregatesFilter<"datasets"> | number
    columns?: JsonWithAggregatesFilter<"datasets">
    row_count?: IntWithAggregatesFilter<"datasets"> | number
    metadata?: JsonNullableWithAggregatesFilter<"datasets">
    created_at?: DateTimeWithAggregatesFilter<"datasets"> | Date | string
  }

  export type analysesWhereInput = {
    AND?: analysesWhereInput | analysesWhereInput[]
    OR?: analysesWhereInput[]
    NOT?: analysesWhereInput | analysesWhereInput[]
    id?: UuidFilter<"analyses"> | string
    project_id?: UuidFilter<"analyses"> | string
    dataset_id?: UuidFilter<"analyses"> | string
    name?: StringFilter<"analyses"> | string
    config?: JsonFilter<"analyses">
    results?: JsonNullableFilter<"analyses">
    status?: StringFilter<"analyses"> | string
    created_at?: DateTimeFilter<"analyses"> | Date | string
    updated_at?: DateTimeFilter<"analyses"> | Date | string
    projects?: XOR<ProjectsScalarRelationFilter, projectsWhereInput>
    datasets?: XOR<DatasetsScalarRelationFilter, datasetsWhereInput>
    clusters?: ClustersListRelationFilter
  }

  export type analysesOrderByWithRelationInput = {
    id?: SortOrder
    project_id?: SortOrder
    dataset_id?: SortOrder
    name?: SortOrder
    config?: SortOrder
    results?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    projects?: projectsOrderByWithRelationInput
    datasets?: datasetsOrderByWithRelationInput
    clusters?: clustersOrderByRelationAggregateInput
  }

  export type analysesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: analysesWhereInput | analysesWhereInput[]
    OR?: analysesWhereInput[]
    NOT?: analysesWhereInput | analysesWhereInput[]
    project_id?: UuidFilter<"analyses"> | string
    dataset_id?: UuidFilter<"analyses"> | string
    name?: StringFilter<"analyses"> | string
    config?: JsonFilter<"analyses">
    results?: JsonNullableFilter<"analyses">
    status?: StringFilter<"analyses"> | string
    created_at?: DateTimeFilter<"analyses"> | Date | string
    updated_at?: DateTimeFilter<"analyses"> | Date | string
    projects?: XOR<ProjectsScalarRelationFilter, projectsWhereInput>
    datasets?: XOR<DatasetsScalarRelationFilter, datasetsWhereInput>
    clusters?: ClustersListRelationFilter
  }, "id">

  export type analysesOrderByWithAggregationInput = {
    id?: SortOrder
    project_id?: SortOrder
    dataset_id?: SortOrder
    name?: SortOrder
    config?: SortOrder
    results?: SortOrderInput | SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: analysesCountOrderByAggregateInput
    _max?: analysesMaxOrderByAggregateInput
    _min?: analysesMinOrderByAggregateInput
  }

  export type analysesScalarWhereWithAggregatesInput = {
    AND?: analysesScalarWhereWithAggregatesInput | analysesScalarWhereWithAggregatesInput[]
    OR?: analysesScalarWhereWithAggregatesInput[]
    NOT?: analysesScalarWhereWithAggregatesInput | analysesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"analyses"> | string
    project_id?: UuidWithAggregatesFilter<"analyses"> | string
    dataset_id?: UuidWithAggregatesFilter<"analyses"> | string
    name?: StringWithAggregatesFilter<"analyses"> | string
    config?: JsonWithAggregatesFilter<"analyses">
    results?: JsonNullableWithAggregatesFilter<"analyses">
    status?: StringWithAggregatesFilter<"analyses"> | string
    created_at?: DateTimeWithAggregatesFilter<"analyses"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"analyses"> | Date | string
  }

  export type clustersWhereInput = {
    AND?: clustersWhereInput | clustersWhereInput[]
    OR?: clustersWhereInput[]
    NOT?: clustersWhereInput | clustersWhereInput[]
    id?: UuidFilter<"clusters"> | string
    analysis_id?: UuidFilter<"clusters"> | string
    cluster_id?: IntFilter<"clusters"> | number
    center_data?: JsonFilter<"clusters">
    point_count?: IntFilter<"clusters"> | number
    characteristics?: JsonNullableFilter<"clusters">
    analyses?: XOR<AnalysesScalarRelationFilter, analysesWhereInput>
  }

  export type clustersOrderByWithRelationInput = {
    id?: SortOrder
    analysis_id?: SortOrder
    cluster_id?: SortOrder
    center_data?: SortOrder
    point_count?: SortOrder
    characteristics?: SortOrderInput | SortOrder
    analyses?: analysesOrderByWithRelationInput
  }

  export type clustersWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: clustersWhereInput | clustersWhereInput[]
    OR?: clustersWhereInput[]
    NOT?: clustersWhereInput | clustersWhereInput[]
    analysis_id?: UuidFilter<"clusters"> | string
    cluster_id?: IntFilter<"clusters"> | number
    center_data?: JsonFilter<"clusters">
    point_count?: IntFilter<"clusters"> | number
    characteristics?: JsonNullableFilter<"clusters">
    analyses?: XOR<AnalysesScalarRelationFilter, analysesWhereInput>
  }, "id">

  export type clustersOrderByWithAggregationInput = {
    id?: SortOrder
    analysis_id?: SortOrder
    cluster_id?: SortOrder
    center_data?: SortOrder
    point_count?: SortOrder
    characteristics?: SortOrderInput | SortOrder
    _count?: clustersCountOrderByAggregateInput
    _avg?: clustersAvgOrderByAggregateInput
    _max?: clustersMaxOrderByAggregateInput
    _min?: clustersMinOrderByAggregateInput
    _sum?: clustersSumOrderByAggregateInput
  }

  export type clustersScalarWhereWithAggregatesInput = {
    AND?: clustersScalarWhereWithAggregatesInput | clustersScalarWhereWithAggregatesInput[]
    OR?: clustersScalarWhereWithAggregatesInput[]
    NOT?: clustersScalarWhereWithAggregatesInput | clustersScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"clusters"> | string
    analysis_id?: UuidWithAggregatesFilter<"clusters"> | string
    cluster_id?: IntWithAggregatesFilter<"clusters"> | number
    center_data?: JsonWithAggregatesFilter<"clusters">
    point_count?: IntWithAggregatesFilter<"clusters"> | number
    characteristics?: JsonNullableWithAggregatesFilter<"clusters">
  }

  export type analysis_templatesWhereInput = {
    AND?: analysis_templatesWhereInput | analysis_templatesWhereInput[]
    OR?: analysis_templatesWhereInput[]
    NOT?: analysis_templatesWhereInput | analysis_templatesWhereInput[]
    id?: UuidFilter<"analysis_templates"> | string
    name?: StringFilter<"analysis_templates"> | string
    description?: StringNullableFilter<"analysis_templates"> | string | null
    config?: JsonFilter<"analysis_templates">
    user_id?: UuidFilter<"analysis_templates"> | string
    is_public?: BoolFilter<"analysis_templates"> | boolean
    created_at?: DateTimeFilter<"analysis_templates"> | Date | string
  }

  export type analysis_templatesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    config?: SortOrder
    user_id?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
  }

  export type analysis_templatesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: analysis_templatesWhereInput | analysis_templatesWhereInput[]
    OR?: analysis_templatesWhereInput[]
    NOT?: analysis_templatesWhereInput | analysis_templatesWhereInput[]
    name?: StringFilter<"analysis_templates"> | string
    description?: StringNullableFilter<"analysis_templates"> | string | null
    config?: JsonFilter<"analysis_templates">
    user_id?: UuidFilter<"analysis_templates"> | string
    is_public?: BoolFilter<"analysis_templates"> | boolean
    created_at?: DateTimeFilter<"analysis_templates"> | Date | string
  }, "id">

  export type analysis_templatesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    config?: SortOrder
    user_id?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    _count?: analysis_templatesCountOrderByAggregateInput
    _max?: analysis_templatesMaxOrderByAggregateInput
    _min?: analysis_templatesMinOrderByAggregateInput
  }

  export type analysis_templatesScalarWhereWithAggregatesInput = {
    AND?: analysis_templatesScalarWhereWithAggregatesInput | analysis_templatesScalarWhereWithAggregatesInput[]
    OR?: analysis_templatesScalarWhereWithAggregatesInput[]
    NOT?: analysis_templatesScalarWhereWithAggregatesInput | analysis_templatesScalarWhereWithAggregatesInput[]
    id?: UuidWithAggregatesFilter<"analysis_templates"> | string
    name?: StringWithAggregatesFilter<"analysis_templates"> | string
    description?: StringNullableWithAggregatesFilter<"analysis_templates"> | string | null
    config?: JsonWithAggregatesFilter<"analysis_templates">
    user_id?: UuidWithAggregatesFilter<"analysis_templates"> | string
    is_public?: BoolWithAggregatesFilter<"analysis_templates"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"analysis_templates"> | Date | string
  }

  export type profilesCreateInput = {
    id?: string
    avatar?: string | null
    username?: string | null
    first_name?: string | null
    last_name?: string | null
    bio?: string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: Date | string | null
    nik?: string | null
    birth_place?: string | null
    users: usersCreateNestedOneWithoutProfileInput
  }

  export type profilesUncheckedCreateInput = {
    id?: string
    user_id: string
    avatar?: string | null
    username?: string | null
    first_name?: string | null
    last_name?: string | null
    bio?: string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: Date | string | null
    nik?: string | null
    birth_place?: string | null
  }

  export type profilesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
    users?: usersUpdateOneRequiredWithoutProfileNestedInput
  }

  export type profilesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type profilesCreateManyInput = {
    id?: string
    user_id: string
    avatar?: string | null
    username?: string | null
    first_name?: string | null
    last_name?: string | null
    bio?: string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: Date | string | null
    nik?: string | null
    birth_place?: string | null
  }

  export type profilesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type profilesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type usersCreateInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type usersCreateManyInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
  }

  export type usersUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
  }

  export type usersUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
  }

  export type rolesCreateInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersCreateNestedManyWithoutRolesInput
    permissions?: permissionsCreateNestedManyWithoutRoleInput
    users?: usersCreateNestedManyWithoutRoleInput
  }

  export type rolesUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersUncheckedCreateNestedManyWithoutRolesInput
    permissions?: permissionsUncheckedCreateNestedManyWithoutRoleInput
    users?: usersUncheckedCreateNestedManyWithoutRoleInput
  }

  export type rolesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUpdateManyWithoutRolesNestedInput
    permissions?: permissionsUpdateManyWithoutRoleNestedInput
    users?: usersUpdateManyWithoutRoleNestedInput
  }

  export type rolesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUncheckedUpdateManyWithoutRolesNestedInput
    permissions?: permissionsUncheckedUpdateManyWithoutRoleNestedInput
    users?: usersUncheckedUpdateManyWithoutRoleNestedInput
  }

  export type rolesCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type rolesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type rolesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsCreateInput = {
    id?: string
    status?: $Enums.session_status
    created_at?: Date | string
    event: eventsCreateNestedOneWithoutSessionsInput
    user: usersCreateNestedOneWithoutSessionsInput
  }

  export type sessionsUncheckedCreateInput = {
    id?: string
    user_id: string
    event_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type sessionsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    event?: eventsUpdateOneRequiredWithoutSessionsNestedInput
    user?: usersUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type sessionsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsCreateManyInput = {
    id?: string
    user_id: string
    event_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type sessionsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type eventsCreateInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    users: usersCreateNestedOneWithoutEventsInput
    locations?: locationsCreateNestedManyWithoutEventInput
    sessions?: sessionsCreateNestedManyWithoutEventInput
  }

  export type eventsUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    user_id: string
    locations?: locationsUncheckedCreateNestedManyWithoutEventInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutEventInput
  }

  export type eventsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutEventsNestedInput
    locations?: locationsUpdateManyWithoutEventNestedInput
    sessions?: sessionsUpdateManyWithoutEventNestedInput
  }

  export type eventsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user_id?: StringFieldUpdateOperationsInput | string
    locations?: locationsUncheckedUpdateManyWithoutEventNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutEventNestedInput
  }

  export type eventsCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    user_id: string
  }

  export type eventsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type eventsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user_id?: StringFieldUpdateOperationsInput | string
  }

  export type resourcesCreateInput = {
    id?: string
    name: string
    type?: string | null
    description?: string | null
    instance_role?: string | null
    relations?: string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    permissions?: permissionsCreateNestedManyWithoutResourceInput
  }

  export type resourcesUncheckedCreateInput = {
    id?: string
    name: string
    type?: string | null
    description?: string | null
    instance_role?: string | null
    relations?: string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    permissions?: permissionsUncheckedCreateNestedManyWithoutResourceInput
  }

  export type resourcesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: permissionsUpdateManyWithoutResourceNestedInput
  }

  export type resourcesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: permissionsUncheckedUpdateManyWithoutResourceNestedInput
  }

  export type resourcesCreateManyInput = {
    id?: string
    name: string
    type?: string | null
    description?: string | null
    instance_role?: string | null
    relations?: string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type resourcesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type resourcesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsCreateInput = {
    id?: string
    action: string
    created_at?: Date | string
    updated_at?: Date | string
    resource: resourcesCreateNestedOneWithoutPermissionsInput
    role: rolesCreateNestedOneWithoutPermissionsInput
  }

  export type permissionsUncheckedCreateInput = {
    id?: string
    action: string
    resource_id: string
    role_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type permissionsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    resource?: resourcesUpdateOneRequiredWithoutPermissionsNestedInput
    role?: rolesUpdateOneRequiredWithoutPermissionsNestedInput
  }

  export type permissionsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    resource_id?: StringFieldUpdateOperationsInput | string
    role_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsCreateManyInput = {
    id?: string
    action: string
    resource_id: string
    role_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type permissionsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    resource_id?: StringFieldUpdateOperationsInput | string
    role_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type citiesCreateInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    districts?: districtsCreateNestedManyWithoutCitiesInput
    units?: unitsCreateNestedManyWithoutCitiesInput
  }

  export type citiesUncheckedCreateInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    districts?: districtsUncheckedCreateNestedManyWithoutCitiesInput
    units?: unitsUncheckedCreateNestedManyWithoutCitiesInput
  }

  export type citiesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    districts?: districtsUpdateManyWithoutCitiesNestedInput
    units?: unitsUpdateManyWithoutCitiesNestedInput
  }

  export type citiesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    districts?: districtsUncheckedUpdateManyWithoutCitiesNestedInput
    units?: unitsUncheckedUpdateManyWithoutCitiesNestedInput
  }

  export type citiesCreateManyInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type citiesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type citiesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type crime_incidentsCreateInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateInput = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsCreateManyInput = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
  }

  export type crime_incidentsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type crime_incidentsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type crime_categoriesCreateInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    crime_incidents?: crime_incidentsCreateNestedManyWithoutCrime_categoriesInput
    incident_logs?: incident_logsCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesUncheckedCreateInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    crime_incidents?: crime_incidentsUncheckedCreateNestedManyWithoutCrime_categoriesInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents?: crime_incidentsUpdateManyWithoutCrime_categoriesNestedInput
    incident_logs?: incident_logsUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type crime_categoriesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutCrime_categoriesNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type crime_categoriesCreateManyInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
  }

  export type crime_categoriesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type crime_categoriesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type crimesCreateInput = {
    id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
    crime_incidents?: crime_incidentsCreateNestedManyWithoutCrimesInput
    districts: districtsCreateNestedOneWithoutCrimesInput
  }

  export type crimesUncheckedCreateInput = {
    id: string
    district_id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
    crime_incidents?: crime_incidentsUncheckedCreateNestedManyWithoutCrimesInput
  }

  export type crimesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
    crime_incidents?: crime_incidentsUpdateManyWithoutCrimesNestedInput
    districts?: districtsUpdateOneRequiredWithoutCrimesNestedInput
  }

  export type crimesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutCrimesNestedInput
  }

  export type crimesCreateManyInput = {
    id: string
    district_id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
  }

  export type crimesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
  }

  export type crimesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
  }

  export type demographicsCreateInput = {
    id?: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
    districts: districtsCreateNestedOneWithoutDemographicsInput
  }

  export type demographicsUncheckedCreateInput = {
    id?: string
    district_id: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type demographicsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    districts?: districtsUpdateOneRequiredWithoutDemographicsNestedInput
  }

  export type demographicsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type demographicsCreateManyInput = {
    id?: string
    district_id: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type demographicsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type demographicsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type districtsCreateInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsCreateManyInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type districtsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type districtsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type locationsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type locationsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type locationsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type incident_logsCreateInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsCreateManyInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type incident_logsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type incident_logsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesCreateInput = {
    id?: string
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_incidents?: crime_incidentsCreateNestedOneWithoutTimelinesInput
    incident?: incident_logsCreateNestedOneWithoutTimelinesInput
    user?: usersCreateNestedOneWithoutTimelinesInput
  }

  export type timelinesUncheckedCreateInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type timelinesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_incidents?: crime_incidentsUpdateOneWithoutTimelinesNestedInput
    incident?: incident_logsUpdateOneWithoutTimelinesNestedInput
    user?: usersUpdateOneWithoutTimelinesNestedInput
  }

  export type timelinesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesCreateManyInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type timelinesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesCreateInput = {
    id?: string
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_incidents?: crime_incidentsCreateNestedOneWithoutWitnessesInput
    incident?: incident_logsCreateNestedOneWithoutWitnessesInput
  }

  export type witnessesUncheckedCreateInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_incidents?: crime_incidentsUpdateOneWithoutWitnessesNestedInput
    incident?: incident_logsUpdateOneWithoutWitnessesNestedInput
  }

  export type witnessesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesCreateManyInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type evidenceCreateInput = {
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
    crime_incidents?: crime_incidentsCreateNestedOneWithoutEvidencesInput
    incident?: incident_logsCreateNestedOneWithoutEvidenceInput
  }

  export type evidenceUncheckedCreateInput = {
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type evidenceUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents?: crime_incidentsUpdateOneWithoutEvidencesNestedInput
    incident?: incident_logsUpdateOneWithoutEvidenceNestedInput
  }

  export type evidenceUncheckedUpdateInput = {
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type evidenceCreateManyInput = {
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type evidenceUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type evidenceUncheckedUpdateManyInput = {
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type unitsUpdateInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUpdateManyWithoutUnitsNestedInput
    cities?: citiesUpdateOneRequiredWithoutUnitsNestedInput
    districts?: districtsUpdateOneWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUncheckedUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput
  }

  export type unitsUpdateManyMutationInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type unitsUncheckedUpdateManyInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type patrol_unitsCreateInput = {
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersCreateNestedManyWithoutPatrol_unitsInput
    location: locationsCreateNestedOneWithoutPatrol_unitsInput
    unit: unitsCreateNestedOneWithoutPatrol_unitsInput
  }

  export type patrol_unitsUncheckedCreateInput = {
    unit_id: string
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersUncheckedCreateNestedManyWithoutPatrol_unitsInput
  }

  export type patrol_unitsUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUpdateManyWithoutPatrol_unitsNestedInput
    location?: locationsUpdateOneRequiredWithoutPatrol_unitsNestedInput
    unit?: unitsUpdateOneRequiredWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsUncheckedUpdateInput = {
    unit_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUncheckedUpdateManyWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsCreateManyInput = {
    unit_id: string
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
  }

  export type patrol_unitsUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type patrol_unitsUncheckedUpdateManyInput = {
    unit_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type officersCreateInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersUpdateInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type officersCreateManyInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
  }

  export type officersUpdateManyMutationInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type officersUncheckedUpdateManyInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unit_statisticsCreateInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
    units: unitsCreateNestedOneWithoutUnit_statisticsInput
  }

  export type unit_statisticsUncheckedCreateInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
    code_unit: string
  }

  export type unit_statisticsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    units?: unitsUpdateOneRequiredWithoutUnit_statisticsNestedInput
  }

  export type unit_statisticsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    code_unit?: StringFieldUpdateOperationsInput | string
  }

  export type unit_statisticsCreateManyInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
    code_unit: string
  }

  export type unit_statisticsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unit_statisticsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    code_unit?: StringFieldUpdateOperationsInput | string
  }

  export type geographicsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    districts?: districtsUpdateOneRequiredWithoutGeographicsNestedInput
  }

  export type geographicsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type geographicsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type geographicsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type contact_messagesCreateInput = {
    id?: string
    name?: string | null
    email?: string | null
    phone?: string | null
    message_type?: string | null
    message_type_label?: string | null
    message?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at: Date | string
  }

  export type contact_messagesUncheckedCreateInput = {
    id?: string
    name?: string | null
    email?: string | null
    phone?: string | null
    message_type?: string | null
    message_type_label?: string | null
    message?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at: Date | string
  }

  export type contact_messagesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type contact_messagesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type contact_messagesCreateManyInput = {
    id?: string
    name?: string | null
    email?: string | null
    phone?: string | null
    message_type?: string | null
    message_type_label?: string | null
    message?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at: Date | string
  }

  export type contact_messagesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type contact_messagesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type messagesCreateInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_user?: usersCreateNestedOneWithoutSentMessagesInput
    sender_officer?: officersCreateNestedOneWithoutSentMessagesInput
    recipient_user?: usersCreateNestedOneWithoutReceivedMessagesInput
    recipient_officer?: officersCreateNestedOneWithoutReceivedMessagesInput
    inbox?: inboxCreateNestedOneWithoutMessagesInput
  }

  export type messagesUncheckedCreateInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_user?: usersUpdateOneWithoutSentMessagesNestedInput
    sender_officer?: officersUpdateOneWithoutSentMessagesNestedInput
    recipient_user?: usersUpdateOneWithoutReceivedMessagesNestedInput
    recipient_officer?: officersUpdateOneWithoutReceivedMessagesNestedInput
    inbox?: inboxUpdateOneWithoutMessagesNestedInput
  }

  export type messagesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesCreateManyInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type inboxCreateInput = {
    id?: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    user: usersCreateNestedOneWithoutInboxInput
    officer: officersCreateNestedOneWithoutInboxInput
    messages?: messagesCreateNestedManyWithoutInboxInput
  }

  export type inboxUncheckedCreateInput = {
    id?: string
    user_id: string
    officer_id: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    messages?: messagesUncheckedCreateNestedManyWithoutInboxInput
  }

  export type inboxUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: usersUpdateOneRequiredWithoutInboxNestedInput
    officer?: officersUpdateOneRequiredWithoutInboxNestedInput
    messages?: messagesUpdateManyWithoutInboxNestedInput
  }

  export type inboxUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    messages?: messagesUncheckedUpdateManyWithoutInboxNestedInput
  }

  export type inboxCreateManyInput = {
    id?: string
    user_id: string
    officer_id: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
  }

  export type inboxUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type inboxUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type logsCreateInput = {
    id?: string
    action: string
    entity: string
    entity_id?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: string | null
    ip_address?: string | null
    user_agent?: string | null
    created_at?: Date | string
  }

  export type logsUncheckedCreateInput = {
    id?: string
    action: string
    entity: string
    entity_id?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: string | null
    ip_address?: string | null
    user_agent?: string | null
    created_at?: Date | string
  }

  export type logsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    entity?: StringFieldUpdateOperationsInput | string
    entity_id?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    ip_address?: NullableStringFieldUpdateOperationsInput | string | null
    user_agent?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type logsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    entity?: StringFieldUpdateOperationsInput | string
    entity_id?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    ip_address?: NullableStringFieldUpdateOperationsInput | string | null
    user_agent?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type logsCreateManyInput = {
    id?: string
    action: string
    entity: string
    entity_id?: string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: string | null
    ip_address?: string | null
    user_agent?: string | null
    created_at?: Date | string
  }

  export type logsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    entity?: StringFieldUpdateOperationsInput | string
    entity_id?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    ip_address?: NullableStringFieldUpdateOperationsInput | string | null
    user_agent?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type logsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    entity?: StringFieldUpdateOperationsInput | string
    entity_id?: NullableStringFieldUpdateOperationsInput | string | null
    changes?: NullableJsonNullValueInput | InputJsonValue
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    ip_address?: NullableStringFieldUpdateOperationsInput | string | null
    user_agent?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsCreateInput = {
    id?: string
    timestamp?: Date | string
    incidents: incident_logsCreateNestedOneWithoutPanic_button_logsInput
    officers?: officersCreateNestedOneWithoutPanic_button_logsInput
    users: usersCreateNestedOneWithoutPanic_button_logsInput
  }

  export type panic_button_logsUncheckedCreateInput = {
    id?: string
    user_id: string
    officer_id?: string | null
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type panic_button_logsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    incidents?: incident_logsUpdateOneRequiredWithoutPanic_button_logsNestedInput
    officers?: officersUpdateOneWithoutPanic_button_logsNestedInput
    users?: usersUpdateOneRequiredWithoutPanic_button_logsNestedInput
  }

  export type panic_button_logsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsCreateManyInput = {
    id?: string
    user_id: string
    officer_id?: string | null
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type panic_button_logsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type location_logsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: locationsUpdateOneRequiredWithoutLocation_logsNestedInput
  }

  export type location_logsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type location_logsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type location_logsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type district_clustersCreateInput = {
    id?: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    district: districtsCreateNestedOneWithoutDistrict_clustersInput
  }

  export type district_clustersUncheckedCreateInput = {
    id?: string
    district_id: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type district_clustersUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    district?: districtsUpdateOneRequiredWithoutDistrict_clustersNestedInput
  }

  export type district_clustersUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type district_clustersCreateManyInput = {
    id?: string
    district_id: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type district_clustersUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type district_clustersUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type cluster_updatesCreateInput = {
    id?: string
    district_id: string
    update_type: string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: boolean
    timestamp?: Date | string
  }

  export type cluster_updatesUncheckedCreateInput = {
    id?: string
    district_id: string
    update_type: string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: boolean
    timestamp?: Date | string
  }

  export type cluster_updatesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    update_type?: StringFieldUpdateOperationsInput | string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: BoolFieldUpdateOperationsInput | boolean
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type cluster_updatesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    update_type?: StringFieldUpdateOperationsInput | string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: BoolFieldUpdateOperationsInput | boolean
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type cluster_updatesCreateManyInput = {
    id?: string
    district_id: string
    update_type: string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: boolean
    timestamp?: Date | string
  }

  export type cluster_updatesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    update_type?: StringFieldUpdateOperationsInput | string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: BoolFieldUpdateOperationsInput | boolean
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type cluster_updatesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    update_type?: StringFieldUpdateOperationsInput | string
    old_value?: NullableJsonNullValueInput | InputJsonValue
    new_value?: NullableJsonNullValueInput | InputJsonValue
    processed?: BoolFieldUpdateOperationsInput | boolean
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type taskCreateInput = {
    id?: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    user: usersCreateNestedOneWithoutTaskInput
  }

  export type taskUncheckedCreateInput = {
    id?: string
    user_id: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type taskUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: usersUpdateOneRequiredWithoutTaskNestedInput
  }

  export type taskUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type taskCreateManyInput = {
    id?: string
    user_id: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type taskUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type taskUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type projectsCreateInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    users: usersCreateNestedOneWithoutProjectsInput
    datasets?: datasetsCreateNestedManyWithoutProjectsInput
    analyses?: analysesCreateNestedManyWithoutProjectsInput
  }

  export type projectsUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
    datasets?: datasetsUncheckedCreateNestedManyWithoutProjectsInput
    analyses?: analysesUncheckedCreateNestedManyWithoutProjectsInput
  }

  export type projectsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutProjectsNestedInput
    datasets?: datasetsUpdateManyWithoutProjectsNestedInput
    analyses?: analysesUpdateManyWithoutProjectsNestedInput
  }

  export type projectsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    datasets?: datasetsUncheckedUpdateManyWithoutProjectsNestedInput
    analyses?: analysesUncheckedUpdateManyWithoutProjectsNestedInput
  }

  export type projectsCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type projectsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type projectsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type datasetsCreateInput = {
    id?: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    projects: projectsCreateNestedOneWithoutDatasetsInput
    analyses?: analysesCreateNestedManyWithoutDatasetsInput
  }

  export type datasetsUncheckedCreateInput = {
    id?: string
    project_id: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    analyses?: analysesUncheckedCreateNestedManyWithoutDatasetsInput
  }

  export type datasetsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    projects?: projectsUpdateOneRequiredWithoutDatasetsNestedInput
    analyses?: analysesUpdateManyWithoutDatasetsNestedInput
  }

  export type datasetsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: analysesUncheckedUpdateManyWithoutDatasetsNestedInput
  }

  export type datasetsCreateManyInput = {
    id?: string
    project_id: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
  }

  export type datasetsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type datasetsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysesCreateInput = {
    id?: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    projects: projectsCreateNestedOneWithoutAnalysesInput
    datasets: datasetsCreateNestedOneWithoutAnalysesInput
    clusters?: clustersCreateNestedManyWithoutAnalysesInput
  }

  export type analysesUncheckedCreateInput = {
    id?: string
    project_id: string
    dataset_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    clusters?: clustersUncheckedCreateNestedManyWithoutAnalysesInput
  }

  export type analysesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    projects?: projectsUpdateOneRequiredWithoutAnalysesNestedInput
    datasets?: datasetsUpdateOneRequiredWithoutAnalysesNestedInput
    clusters?: clustersUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    dataset_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    clusters?: clustersUncheckedUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesCreateManyInput = {
    id?: string
    project_id: string
    dataset_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type analysesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    dataset_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type clustersCreateInput = {
    id?: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
    analyses: analysesCreateNestedOneWithoutClustersInput
  }

  export type clustersUncheckedCreateInput = {
    id?: string
    analysis_id: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
    analyses?: analysesUpdateOneRequiredWithoutClustersNestedInput
  }

  export type clustersUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    analysis_id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersCreateManyInput = {
    id?: string
    analysis_id: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    analysis_id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type analysis_templatesCreateInput = {
    id?: string
    name: string
    description?: string | null
    config: JsonNullValueInput | InputJsonValue
    user_id: string
    is_public?: boolean
    created_at?: Date | string
  }

  export type analysis_templatesUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    config: JsonNullValueInput | InputJsonValue
    user_id: string
    is_public?: boolean
    created_at?: Date | string
  }

  export type analysis_templatesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    config?: JsonNullValueInput | InputJsonValue
    user_id?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysis_templatesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    config?: JsonNullValueInput | InputJsonValue
    user_id?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysis_templatesCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    config: JsonNullValueInput | InputJsonValue
    user_id: string
    is_public?: boolean
    created_at?: Date | string
  }

  export type analysis_templatesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    config?: JsonNullValueInput | InputJsonValue
    user_id?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysis_templatesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    config?: JsonNullValueInput | InputJsonValue
    user_id?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UuidFilter<$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>
    mode?: QueryMode
    not?: NestedUuidFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }
  export type JsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type 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 UsersScalarRelationFilter = {
    is?: usersWhereInput
    isNot?: usersWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type profilesCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    avatar?: SortOrder
    username?: SortOrder
    first_name?: SortOrder
    last_name?: SortOrder
    bio?: SortOrder
    address?: SortOrder
    birth_date?: SortOrder
    nik?: SortOrder
    birth_place?: SortOrder
  }

  export type profilesMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    avatar?: SortOrder
    username?: SortOrder
    first_name?: SortOrder
    last_name?: SortOrder
    bio?: SortOrder
    birth_date?: SortOrder
    nik?: SortOrder
    birth_place?: SortOrder
  }

  export type profilesMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    avatar?: SortOrder
    username?: SortOrder
    first_name?: SortOrder
    last_name?: SortOrder
    bio?: SortOrder
    birth_date?: SortOrder
    nik?: SortOrder
    birth_place?: SortOrder
  }

  export type UuidWithAggregatesFilter<$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>
    mode?: QueryMode
    not?: NestedUuidWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }
  export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type 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 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 DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type 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 EventsListRelationFilter = {
    every?: eventsWhereInput
    some?: eventsWhereInput
    none?: eventsWhereInput
  }

  export type Incident_logsListRelationFilter = {
    every?: incident_logsWhereInput
    some?: incident_logsWhereInput
    none?: incident_logsWhereInput
  }

  export type Panic_button_logsListRelationFilter = {
    every?: panic_button_logsWhereInput
    some?: panic_button_logsWhereInput
    none?: panic_button_logsWhereInput
  }

  export type ProfilesNullableScalarRelationFilter = {
    is?: profilesWhereInput | null
    isNot?: profilesWhereInput | null
  }

  export type SessionsListRelationFilter = {
    every?: sessionsWhereInput
    some?: sessionsWhereInput
    none?: sessionsWhereInput
  }

  export type TimelinesListRelationFilter = {
    every?: timelinesWhereInput
    some?: timelinesWhereInput
    none?: timelinesWhereInput
  }

  export type RolesScalarRelationFilter = {
    is?: rolesWhereInput
    isNot?: rolesWhereInput
  }

  export type TaskListRelationFilter = {
    every?: taskWhereInput
    some?: taskWhereInput
    none?: taskWhereInput
  }

  export type MessagesListRelationFilter = {
    every?: messagesWhereInput
    some?: messagesWhereInput
    none?: messagesWhereInput
  }

  export type ProjectsListRelationFilter = {
    every?: projectsWhereInput
    some?: projectsWhereInput
    none?: projectsWhereInput
  }

  export type InboxNullableScalarRelationFilter = {
    is?: inboxWhereInput | null
    isNot?: inboxWhereInput | null
  }

  export type eventsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type incident_logsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type panic_button_logsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type sessionsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type timelinesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type taskOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type messagesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type projectsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type usersCountOrderByAggregateInput = {
    id?: SortOrder
    roles_id?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    encrypted_password?: SortOrder
    invited_at?: SortOrder
    confirmed_at?: SortOrder
    email_confirmed_at?: SortOrder
    recovery_sent_at?: SortOrder
    last_sign_in_at?: SortOrder
    app_metadata?: SortOrder
    user_metadata?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    banned_until?: SortOrder
    is_anonymous?: SortOrder
    banned_reason?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type usersAvgOrderByAggregateInput = {
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type usersMaxOrderByAggregateInput = {
    id?: SortOrder
    roles_id?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    encrypted_password?: SortOrder
    invited_at?: SortOrder
    confirmed_at?: SortOrder
    email_confirmed_at?: SortOrder
    recovery_sent_at?: SortOrder
    last_sign_in_at?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    banned_until?: SortOrder
    is_anonymous?: SortOrder
    banned_reason?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type usersMinOrderByAggregateInput = {
    id?: SortOrder
    roles_id?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    encrypted_password?: SortOrder
    invited_at?: SortOrder
    confirmed_at?: SortOrder
    email_confirmed_at?: SortOrder
    recovery_sent_at?: SortOrder
    last_sign_in_at?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    banned_until?: SortOrder
    is_anonymous?: SortOrder
    banned_reason?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type usersSumOrderByAggregateInput = {
    panic_strike?: SortOrder
    spoofing_attempts?: 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 DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type 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 OfficersListRelationFilter = {
    every?: officersWhereInput
    some?: officersWhereInput
    none?: officersWhereInput
  }

  export type PermissionsListRelationFilter = {
    every?: permissionsWhereInput
    some?: permissionsWhereInput
    none?: permissionsWhereInput
  }

  export type UsersListRelationFilter = {
    every?: usersWhereInput
    some?: usersWhereInput
    none?: usersWhereInput
  }

  export type officersOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type permissionsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type usersOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type rolesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type rolesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type rolesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type Enumsession_statusFilter<$PrismaModel = never> = {
    equals?: $Enums.session_status | Enumsession_statusFieldRefInput<$PrismaModel>
    in?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumsession_statusFilter<$PrismaModel> | $Enums.session_status
  }

  export type EventsScalarRelationFilter = {
    is?: eventsWhereInput
    isNot?: eventsWhereInput
  }

  export type sessionsCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    event_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
  }

  export type sessionsMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    event_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
  }

  export type sessionsMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    event_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
  }

  export type Enumsession_statusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.session_status | Enumsession_statusFieldRefInput<$PrismaModel>
    in?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumsession_statusWithAggregatesFilter<$PrismaModel> | $Enums.session_status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumsession_statusFilter<$PrismaModel>
    _max?: NestedEnumsession_statusFilter<$PrismaModel>
  }

  export type LocationsListRelationFilter = {
    every?: locationsWhereInput
    some?: locationsWhereInput
    none?: locationsWhereInput
  }

  export type locationsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type eventsCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    code?: SortOrder
    created_at?: SortOrder
    user_id?: SortOrder
  }

  export type eventsMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    code?: SortOrder
    created_at?: SortOrder
    user_id?: SortOrder
  }

  export type eventsMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    code?: SortOrder
    created_at?: SortOrder
    user_id?: SortOrder
  }

  export type resourcesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    description?: SortOrder
    instance_role?: SortOrder
    relations?: SortOrder
    attributes?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type resourcesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    description?: SortOrder
    instance_role?: SortOrder
    relations?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type resourcesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    description?: SortOrder
    instance_role?: SortOrder
    relations?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ResourcesScalarRelationFilter = {
    is?: resourcesWhereInput
    isNot?: resourcesWhereInput
  }

  export type permissionsCountOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    resource_id?: SortOrder
    role_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type permissionsMaxOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    resource_id?: SortOrder
    role_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type permissionsMinOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    resource_id?: SortOrder
    role_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type DistrictsListRelationFilter = {
    every?: districtsWhereInput
    some?: districtsWhereInput
    none?: districtsWhereInput
  }

  export type UnitsListRelationFilter = {
    every?: unitsWhereInput
    some?: unitsWhereInput
    none?: unitsWhereInput
  }

  export type districtsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type unitsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type citiesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type citiesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type citiesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type Enumcrime_statusNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_status | Enumcrime_statusFieldRefInput<$PrismaModel> | null
    in?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumcrime_statusNullableFilter<$PrismaModel> | $Enums.crime_status | null
  }

  export type Crime_categoriesScalarRelationFilter = {
    is?: crime_categoriesWhereInput
    isNot?: crime_categoriesWhereInput
  }

  export type CrimesScalarRelationFilter = {
    is?: crimesWhereInput
    isNot?: crimesWhereInput
  }

  export type LocationsScalarRelationFilter = {
    is?: locationsWhereInput
    isNot?: locationsWhereInput
  }

  export type EvidenceListRelationFilter = {
    every?: evidenceWhereInput
    some?: evidenceWhereInput
    none?: evidenceWhereInput
  }

  export type WitnessesListRelationFilter = {
    every?: witnessesWhereInput
    some?: witnessesWhereInput
    none?: witnessesWhereInput
  }

  export type evidenceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type witnessesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type crime_incidentsCountOrderByAggregateInput = {
    id?: SortOrder
    crime_id?: SortOrder
    crime_category_id?: SortOrder
    location_id?: SortOrder
    description?: SortOrder
    victim_count?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    timestamp?: SortOrder
  }

  export type crime_incidentsAvgOrderByAggregateInput = {
    victim_count?: SortOrder
  }

  export type crime_incidentsMaxOrderByAggregateInput = {
    id?: SortOrder
    crime_id?: SortOrder
    crime_category_id?: SortOrder
    location_id?: SortOrder
    description?: SortOrder
    victim_count?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    timestamp?: SortOrder
  }

  export type crime_incidentsMinOrderByAggregateInput = {
    id?: SortOrder
    crime_id?: SortOrder
    crime_category_id?: SortOrder
    location_id?: SortOrder
    description?: SortOrder
    victim_count?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    timestamp?: SortOrder
  }

  export type crime_incidentsSumOrderByAggregateInput = {
    victim_count?: SortOrder
  }

  export type Enumcrime_statusNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_status | Enumcrime_statusFieldRefInput<$PrismaModel> | null
    in?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumcrime_statusNullableWithAggregatesFilter<$PrismaModel> | $Enums.crime_status | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumcrime_statusNullableFilter<$PrismaModel>
    _max?: NestedEnumcrime_statusNullableFilter<$PrismaModel>
  }

  export type Crime_incidentsListRelationFilter = {
    every?: crime_incidentsWhereInput
    some?: crime_incidentsWhereInput
    none?: crime_incidentsWhereInput
  }

  export type crime_incidentsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type crime_categoriesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    type?: SortOrder
  }

  export type crime_categoriesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    type?: SortOrder
  }

  export type crime_categoriesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    type?: SortOrder
  }

  export type Enumcrime_ratesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_rates | Enumcrime_ratesFieldRefInput<$PrismaModel>
    in?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    notIn?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    not?: NestedEnumcrime_ratesFilter<$PrismaModel> | $Enums.crime_rates
  }

  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 FloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type DistrictsScalarRelationFilter = {
    is?: districtsWhereInput
    isNot?: districtsWhereInput
  }

  export type crimesCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    created_at?: SortOrder
    level?: SortOrder
    method?: SortOrder
    month?: SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    updated_at?: SortOrder
    year?: SortOrder
    source_type?: SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
  }

  export type crimesAvgOrderByAggregateInput = {
    month?: SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    year?: SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
  }

  export type crimesMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    created_at?: SortOrder
    level?: SortOrder
    method?: SortOrder
    month?: SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    updated_at?: SortOrder
    year?: SortOrder
    source_type?: SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
  }

  export type crimesMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    created_at?: SortOrder
    level?: SortOrder
    method?: SortOrder
    month?: SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    updated_at?: SortOrder
    year?: SortOrder
    source_type?: SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
  }

  export type crimesSumOrderByAggregateInput = {
    month?: SortOrder
    number_of_crime?: SortOrder
    score?: SortOrder
    year?: SortOrder
    crime_cleared?: SortOrder
    avg_crime?: SortOrder
  }

  export type Enumcrime_ratesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_rates | Enumcrime_ratesFieldRefInput<$PrismaModel>
    in?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    notIn?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    not?: NestedEnumcrime_ratesWithAggregatesFilter<$PrismaModel> | $Enums.crime_rates
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumcrime_ratesFilter<$PrismaModel>
    _max?: NestedEnumcrime_ratesFilter<$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 FloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type demographicsDistrict_idYearCompoundUniqueInput = {
    district_id: string
    year: number
  }

  export type demographicsCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type demographicsAvgOrderByAggregateInput = {
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
  }

  export type demographicsMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type demographicsMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type demographicsSumOrderByAggregateInput = {
    population?: SortOrder
    number_of_unemployed?: SortOrder
    population_density?: SortOrder
    year?: SortOrder
  }

  export type CrimesListRelationFilter = {
    every?: crimesWhereInput
    some?: crimesWhereInput
    none?: crimesWhereInput
  }

  export type DemographicsListRelationFilter = {
    every?: demographicsWhereInput
    some?: demographicsWhereInput
    none?: demographicsWhereInput
  }

  export type District_clustersListRelationFilter = {
    every?: district_clustersWhereInput
    some?: district_clustersWhereInput
    none?: district_clustersWhereInput
  }

  export type CitiesScalarRelationFilter = {
    is?: citiesWhereInput
    isNot?: citiesWhereInput
  }

  export type GeographicsListRelationFilter = {
    every?: geographicsWhereInput
    some?: geographicsWhereInput
    none?: geographicsWhereInput
  }

  export type UnitsNullableScalarRelationFilter = {
    is?: unitsWhereInput | null
    isNot?: unitsWhereInput | null
  }

  export type crimesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type demographicsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type district_clustersOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type geographicsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type districtsCountOrderByAggregateInput = {
    id?: SortOrder
    city_id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type districtsMaxOrderByAggregateInput = {
    id?: SortOrder
    city_id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type districtsMinOrderByAggregateInput = {
    id?: SortOrder
    city_id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type Location_logsListRelationFilter = {
    every?: location_logsWhereInput
    some?: location_logsWhereInput
    none?: location_logsWhereInput
  }

  export type Patrol_unitsListRelationFilter = {
    every?: patrol_unitsWhereInput
    some?: patrol_unitsWhereInput
    none?: patrol_unitsWhereInput
  }

  export type location_logsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type patrol_unitsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type locationsCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    event_id?: SortOrder
    address?: SortOrder
    type?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    distance_to_unit?: SortOrder
  }

  export type locationsAvgOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrder
    distance_to_unit?: SortOrder
  }

  export type locationsMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    event_id?: SortOrder
    address?: SortOrder
    type?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    distance_to_unit?: SortOrder
  }

  export type locationsMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    event_id?: SortOrder
    address?: SortOrder
    type?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    distance_to_unit?: SortOrder
  }

  export type locationsSumOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
    land_area?: SortOrder
    distance_to_unit?: SortOrder
  }

  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type BoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type incident_logsCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    location_id?: SortOrder
    category_id?: SortOrder
    description?: SortOrder
    source?: SortOrder
    time?: SortOrder
    verified?: SortOrder
    severity?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type incident_logsMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    location_id?: SortOrder
    category_id?: SortOrder
    description?: SortOrder
    source?: SortOrder
    time?: SortOrder
    verified?: SortOrder
    severity?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type incident_logsMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    location_id?: SortOrder
    category_id?: SortOrder
    description?: SortOrder
    source?: SortOrder
    time?: SortOrder
    verified?: SortOrder
    severity?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  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 UuidNullableFilter<$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>
    mode?: QueryMode
    not?: NestedUuidNullableFilter<$PrismaModel> | string | null
  }

  export type Crime_incidentsNullableScalarRelationFilter = {
    is?: crime_incidentsWhereInput | null
    isNot?: crime_incidentsWhereInput | null
  }

  export type Incident_logsNullableScalarRelationFilter = {
    is?: incident_logsWhereInput | null
    isNot?: incident_logsWhereInput | null
  }

  export type UsersNullableScalarRelationFilter = {
    is?: usersWhereInput | null
    isNot?: usersWhereInput | null
  }

  export type timelinesCountOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    user_id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    timestamp?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type timelinesMaxOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    user_id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    timestamp?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type timelinesMinOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    user_id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    timestamp?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UuidNullableWithAggregatesFilter<$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>
    mode?: QueryMode
    not?: NestedUuidNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type witnessesCountOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    name?: SortOrder
    contact_info?: SortOrder
    statement?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type witnessesMaxOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    name?: SortOrder
    contact_info?: SortOrder
    statement?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type witnessesMinOrderByAggregateInput = {
    id?: SortOrder
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    name?: SortOrder
    contact_info?: SortOrder
    statement?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type evidenceCountOrderByAggregateInput = {
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    type?: SortOrder
    url?: SortOrder
    status?: SortOrder
    uploaded_at?: SortOrder
    updated_at?: SortOrder
    caption?: SortOrder
    description?: SortOrder
    metadata?: SortOrder
    id?: SortOrder
  }

  export type evidenceMaxOrderByAggregateInput = {
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    type?: SortOrder
    url?: SortOrder
    status?: SortOrder
    uploaded_at?: SortOrder
    updated_at?: SortOrder
    caption?: SortOrder
    description?: SortOrder
    id?: SortOrder
  }

  export type evidenceMinOrderByAggregateInput = {
    incident_logs_id?: SortOrder
    crime_incidents_id?: SortOrder
    type?: SortOrder
    url?: SortOrder
    status?: SortOrder
    uploaded_at?: SortOrder
    updated_at?: SortOrder
    caption?: SortOrder
    description?: SortOrder
    id?: SortOrder
  }

  export type Enumunit_typeFilter<$PrismaModel = never> = {
    equals?: $Enums.unit_type | Enumunit_typeFieldRefInput<$PrismaModel>
    in?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    notIn?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    not?: NestedEnumunit_typeFilter<$PrismaModel> | $Enums.unit_type
  }

  export type Unit_statisticsListRelationFilter = {
    every?: unit_statisticsWhereInput
    some?: unit_statisticsWhereInput
    none?: unit_statisticsWhereInput
  }

  export type DistrictsNullableScalarRelationFilter = {
    is?: districtsWhereInput | null
    isNot?: districtsWhereInput | null
  }

  export type unit_statisticsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type unitsCountOrderByAggregateInput = {
    code_unit?: SortOrder
    district_id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    address?: SortOrder
    land_area?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    city_id?: SortOrder
    phone?: SortOrder
  }

  export type unitsAvgOrderByAggregateInput = {
    land_area?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type unitsMaxOrderByAggregateInput = {
    code_unit?: SortOrder
    district_id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    address?: SortOrder
    land_area?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    city_id?: SortOrder
    phone?: SortOrder
  }

  export type unitsMinOrderByAggregateInput = {
    code_unit?: SortOrder
    district_id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    address?: SortOrder
    land_area?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    city_id?: SortOrder
    phone?: SortOrder
  }

  export type unitsSumOrderByAggregateInput = {
    land_area?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type Enumunit_typeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.unit_type | Enumunit_typeFieldRefInput<$PrismaModel>
    in?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    notIn?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    not?: NestedEnumunit_typeWithAggregatesFilter<$PrismaModel> | $Enums.unit_type
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumunit_typeFilter<$PrismaModel>
    _max?: NestedEnumunit_typeFilter<$PrismaModel>
  }

  export type Enumpatrol_unit_categoryNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.patrol_unit_category | Enumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    in?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    not?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel> | $Enums.patrol_unit_category | null
  }

  export type UnitsScalarRelationFilter = {
    is?: unitsWhereInput
    isNot?: unitsWhereInput
  }

  export type patrol_unitsCountOrderByAggregateInput = {
    unit_id?: SortOrder
    location_id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    status?: SortOrder
    radius?: SortOrder
    created_at?: SortOrder
    id?: SortOrder
    category?: SortOrder
    member_count?: SortOrder
    updated_at?: SortOrder
  }

  export type patrol_unitsAvgOrderByAggregateInput = {
    radius?: SortOrder
    member_count?: SortOrder
  }

  export type patrol_unitsMaxOrderByAggregateInput = {
    unit_id?: SortOrder
    location_id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    status?: SortOrder
    radius?: SortOrder
    created_at?: SortOrder
    id?: SortOrder
    category?: SortOrder
    member_count?: SortOrder
    updated_at?: SortOrder
  }

  export type patrol_unitsMinOrderByAggregateInput = {
    unit_id?: SortOrder
    location_id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    status?: SortOrder
    radius?: SortOrder
    created_at?: SortOrder
    id?: SortOrder
    category?: SortOrder
    member_count?: SortOrder
    updated_at?: SortOrder
  }

  export type patrol_unitsSumOrderByAggregateInput = {
    radius?: SortOrder
    member_count?: SortOrder
  }

  export type Enumpatrol_unit_categoryNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.patrol_unit_category | Enumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    in?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    not?: NestedEnumpatrol_unit_categoryNullableWithAggregatesFilter<$PrismaModel> | $Enums.patrol_unit_category | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel>
    _max?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel>
  }

  export type Patrol_unitsNullableScalarRelationFilter = {
    is?: patrol_unitsWhereInput | null
    isNot?: patrol_unitsWhereInput | null
  }

  export type officersCountOrderByAggregateInput = {
    unit_id?: SortOrder
    role_id?: SortOrder
    nrp?: SortOrder
    name?: SortOrder
    rank?: SortOrder
    position?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    avatar?: SortOrder
    valid_until?: SortOrder
    qr_code?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    patrol_unit_id?: SortOrder
    id?: SortOrder
    banned_reason?: SortOrder
    banned_until?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    place_of_birth?: SortOrder
    date_of_birth?: SortOrder
  }

  export type officersAvgOrderByAggregateInput = {
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type officersMaxOrderByAggregateInput = {
    unit_id?: SortOrder
    role_id?: SortOrder
    nrp?: SortOrder
    name?: SortOrder
    rank?: SortOrder
    position?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    avatar?: SortOrder
    valid_until?: SortOrder
    qr_code?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    patrol_unit_id?: SortOrder
    id?: SortOrder
    banned_reason?: SortOrder
    banned_until?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    place_of_birth?: SortOrder
    date_of_birth?: SortOrder
  }

  export type officersMinOrderByAggregateInput = {
    unit_id?: SortOrder
    role_id?: SortOrder
    nrp?: SortOrder
    name?: SortOrder
    rank?: SortOrder
    position?: SortOrder
    phone?: SortOrder
    email?: SortOrder
    avatar?: SortOrder
    valid_until?: SortOrder
    qr_code?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    patrol_unit_id?: SortOrder
    id?: SortOrder
    banned_reason?: SortOrder
    banned_until?: SortOrder
    is_banned?: SortOrder
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
    place_of_birth?: SortOrder
    date_of_birth?: SortOrder
  }

  export type officersSumOrderByAggregateInput = {
    panic_strike?: SortOrder
    spoofing_attempts?: SortOrder
  }

  export type unit_statisticsCode_unitMonthYearCompoundUniqueInput = {
    code_unit: string
    month: number
    year: number
  }

  export type unit_statisticsCountOrderByAggregateInput = {
    id?: SortOrder
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrder
    pending?: SortOrder
    month?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    code_unit?: SortOrder
  }

  export type unit_statisticsAvgOrderByAggregateInput = {
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrder
    pending?: SortOrder
    month?: SortOrder
    year?: SortOrder
  }

  export type unit_statisticsMaxOrderByAggregateInput = {
    id?: SortOrder
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrder
    pending?: SortOrder
    month?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    code_unit?: SortOrder
  }

  export type unit_statisticsMinOrderByAggregateInput = {
    id?: SortOrder
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrder
    pending?: SortOrder
    month?: SortOrder
    year?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    code_unit?: SortOrder
  }

  export type unit_statisticsSumOrderByAggregateInput = {
    crime_total?: SortOrder
    crime_cleared?: SortOrder
    percentage?: SortOrder
    pending?: SortOrder
    month?: SortOrder
    year?: SortOrder
  }

  export type geographicsCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    address?: SortOrder
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    description?: SortOrder
    type?: SortOrder
    year?: SortOrder
  }

  export type geographicsAvgOrderByAggregateInput = {
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrder
    year?: SortOrder
  }

  export type geographicsMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    address?: SortOrder
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    description?: SortOrder
    type?: SortOrder
    year?: SortOrder
  }

  export type geographicsMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    address?: SortOrder
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    description?: SortOrder
    type?: SortOrder
    year?: SortOrder
  }

  export type geographicsSumOrderByAggregateInput = {
    longitude?: SortOrder
    latitude?: SortOrder
    land_area?: SortOrder
    year?: SortOrder
  }

  export type Enumstatus_messagesFilter<$PrismaModel = never> = {
    equals?: $Enums.status_messages | Enumstatus_messagesFieldRefInput<$PrismaModel>
    in?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    notIn?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    not?: NestedEnumstatus_messagesFilter<$PrismaModel> | $Enums.status_messages
  }

  export type contact_messagesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    message?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type contact_messagesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    message?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type contact_messagesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    message?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type Enumstatus_messagesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.status_messages | Enumstatus_messagesFieldRefInput<$PrismaModel>
    in?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    notIn?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    not?: NestedEnumstatus_messagesWithAggregatesFilter<$PrismaModel> | $Enums.status_messages
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumstatus_messagesFilter<$PrismaModel>
    _max?: NestedEnumstatus_messagesFilter<$PrismaModel>
  }

  export type OfficersNullableScalarRelationFilter = {
    is?: officersWhereInput | null
    isNot?: officersWhereInput | null
  }

  export type messagesCountOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    content?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    sender_user_id?: SortOrder
    sender_officer_id?: SortOrder
    recipient_user_id?: SortOrder
    recipient_officer_id?: SortOrder
    inbox_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    file_url?: SortOrder
    file_type?: SortOrder
    file_name?: SortOrder
    is_starred?: SortOrder
  }

  export type messagesMaxOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    content?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    sender_user_id?: SortOrder
    sender_officer_id?: SortOrder
    recipient_user_id?: SortOrder
    recipient_officer_id?: SortOrder
    inbox_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    file_url?: SortOrder
    file_type?: SortOrder
    file_name?: SortOrder
    is_starred?: SortOrder
  }

  export type messagesMinOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    content?: SortOrder
    message_type?: SortOrder
    message_type_label?: SortOrder
    sender_user_id?: SortOrder
    sender_officer_id?: SortOrder
    recipient_user_id?: SortOrder
    recipient_officer_id?: SortOrder
    inbox_id?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    file_url?: SortOrder
    file_type?: SortOrder
    file_name?: SortOrder
    is_starred?: SortOrder
  }

  export type OfficersScalarRelationFilter = {
    is?: officersWhereInput
    isNot?: officersWhereInput
  }

  export type inboxCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    unread_count?: SortOrder
    last_updated?: SortOrder
    created_at?: SortOrder
  }

  export type inboxAvgOrderByAggregateInput = {
    unread_count?: SortOrder
  }

  export type inboxMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    unread_count?: SortOrder
    last_updated?: SortOrder
    created_at?: SortOrder
  }

  export type inboxMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    unread_count?: SortOrder
    last_updated?: SortOrder
    created_at?: SortOrder
  }

  export type inboxSumOrderByAggregateInput = {
    unread_count?: SortOrder
  }

  export type logsCountOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    entity?: SortOrder
    entity_id?: SortOrder
    changes?: SortOrder
    user_id?: SortOrder
    ip_address?: SortOrder
    user_agent?: SortOrder
    created_at?: SortOrder
  }

  export type logsMaxOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    entity?: SortOrder
    entity_id?: SortOrder
    user_id?: SortOrder
    ip_address?: SortOrder
    user_agent?: SortOrder
    created_at?: SortOrder
  }

  export type logsMinOrderByAggregateInput = {
    id?: SortOrder
    action?: SortOrder
    entity?: SortOrder
    entity_id?: SortOrder
    user_id?: SortOrder
    ip_address?: SortOrder
    user_agent?: SortOrder
    created_at?: SortOrder
  }

  export type Incident_logsScalarRelationFilter = {
    is?: incident_logsWhereInput
    isNot?: incident_logsWhereInput
  }

  export type panic_button_logsCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    incident_logs_id?: SortOrder
    timestamp?: SortOrder
  }

  export type panic_button_logsMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    incident_logs_id?: SortOrder
    timestamp?: SortOrder
  }

  export type panic_button_logsMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    officer_id?: SortOrder
    incident_logs_id?: SortOrder
    timestamp?: SortOrder
  }

  export type location_logsCountOrderByAggregateInput = {
    id?: SortOrder
    location_id?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    timestamp?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type location_logsAvgOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type location_logsMaxOrderByAggregateInput = {
    id?: SortOrder
    location_id?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    timestamp?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type location_logsMinOrderByAggregateInput = {
    id?: SortOrder
    location_id?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    timestamp?: SortOrder
    description?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type location_logsSumOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type district_clustersDistrict_idYearMonthCompoundUniqueInput = {
    district_id: string
    year: number
    month: number
  }

  export type district_clustersCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    year?: SortOrder
    month?: SortOrder
    risk_level?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    centroid_features?: SortOrder
    member_count?: SortOrder
    last_update_type?: SortOrder
    update_count?: SortOrder
    needs_recompute?: SortOrder
    incidents_data?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type district_clustersAvgOrderByAggregateInput = {
    year?: SortOrder
    month?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    member_count?: SortOrder
    update_count?: SortOrder
  }

  export type district_clustersMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    year?: SortOrder
    month?: SortOrder
    risk_level?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    member_count?: SortOrder
    last_update_type?: SortOrder
    update_count?: SortOrder
    needs_recompute?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type district_clustersMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    year?: SortOrder
    month?: SortOrder
    risk_level?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    member_count?: SortOrder
    last_update_type?: SortOrder
    update_count?: SortOrder
    needs_recompute?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type district_clustersSumOrderByAggregateInput = {
    year?: SortOrder
    month?: SortOrder
    total_crimes?: SortOrder
    population_density?: SortOrder
    unemployment_rate?: SortOrder
    crime_score?: SortOrder
    density_score?: SortOrder
    unemployment_score?: SortOrder
    cluster_score?: SortOrder
    member_count?: SortOrder
    update_count?: SortOrder
  }

  export type cluster_updatesCountOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    update_type?: SortOrder
    old_value?: SortOrder
    new_value?: SortOrder
    processed?: SortOrder
    timestamp?: SortOrder
  }

  export type cluster_updatesMaxOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    update_type?: SortOrder
    processed?: SortOrder
    timestamp?: SortOrder
  }

  export type cluster_updatesMinOrderByAggregateInput = {
    id?: SortOrder
    district_id?: SortOrder
    update_type?: SortOrder
    processed?: SortOrder
    timestamp?: SortOrder
  }

  export type Enumtask_statusFilter<$PrismaModel = never> = {
    equals?: $Enums.task_status | Enumtask_statusFieldRefInput<$PrismaModel>
    in?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_statusFilter<$PrismaModel> | $Enums.task_status
  }

  export type Enumtask_labelFilter<$PrismaModel = never> = {
    equals?: $Enums.task_label | Enumtask_labelFieldRefInput<$PrismaModel>
    in?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_labelFilter<$PrismaModel> | $Enums.task_label
  }

  export type Enumtask_priorityFilter<$PrismaModel = never> = {
    equals?: $Enums.task_priority | Enumtask_priorityFieldRefInput<$PrismaModel>
    in?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_priorityFilter<$PrismaModel> | $Enums.task_priority
  }

  export type taskCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    code?: SortOrder
    title?: SortOrder
    status?: SortOrder
    label?: SortOrder
    priority?: SortOrder
    estimated_hours?: SortOrder
    archived?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type taskAvgOrderByAggregateInput = {
    estimated_hours?: SortOrder
  }

  export type taskMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    code?: SortOrder
    title?: SortOrder
    status?: SortOrder
    label?: SortOrder
    priority?: SortOrder
    estimated_hours?: SortOrder
    archived?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type taskMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    code?: SortOrder
    title?: SortOrder
    status?: SortOrder
    label?: SortOrder
    priority?: SortOrder
    estimated_hours?: SortOrder
    archived?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type taskSumOrderByAggregateInput = {
    estimated_hours?: SortOrder
  }

  export type Enumtask_statusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_status | Enumtask_statusFieldRefInput<$PrismaModel>
    in?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_statusWithAggregatesFilter<$PrismaModel> | $Enums.task_status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_statusFilter<$PrismaModel>
    _max?: NestedEnumtask_statusFilter<$PrismaModel>
  }

  export type Enumtask_labelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_label | Enumtask_labelFieldRefInput<$PrismaModel>
    in?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_labelWithAggregatesFilter<$PrismaModel> | $Enums.task_label
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_labelFilter<$PrismaModel>
    _max?: NestedEnumtask_labelFilter<$PrismaModel>
  }

  export type Enumtask_priorityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_priority | Enumtask_priorityFieldRefInput<$PrismaModel>
    in?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_priorityWithAggregatesFilter<$PrismaModel> | $Enums.task_priority
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_priorityFilter<$PrismaModel>
    _max?: NestedEnumtask_priorityFilter<$PrismaModel>
  }

  export type DatasetsListRelationFilter = {
    every?: datasetsWhereInput
    some?: datasetsWhereInput
    none?: datasetsWhereInput
  }

  export type AnalysesListRelationFilter = {
    every?: analysesWhereInput
    some?: analysesWhereInput
    none?: analysesWhereInput
  }

  export type datasetsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type analysesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type projectsCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type projectsMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type projectsMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }
  export type JsonFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>

  export type JsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type ProjectsScalarRelationFilter = {
    is?: projectsWhereInput
    isNot?: projectsWhereInput
  }

  export type datasetsCountOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    filename?: SortOrder
    original_name?: SortOrder
    file_size?: SortOrder
    columns?: SortOrder
    row_count?: SortOrder
    metadata?: SortOrder
    created_at?: SortOrder
  }

  export type datasetsAvgOrderByAggregateInput = {
    file_size?: SortOrder
    row_count?: SortOrder
  }

  export type datasetsMaxOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    filename?: SortOrder
    original_name?: SortOrder
    file_size?: SortOrder
    row_count?: SortOrder
    created_at?: SortOrder
  }

  export type datasetsMinOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    filename?: SortOrder
    original_name?: SortOrder
    file_size?: SortOrder
    row_count?: SortOrder
    created_at?: SortOrder
  }

  export type datasetsSumOrderByAggregateInput = {
    file_size?: SortOrder
    row_count?: SortOrder
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type DatasetsScalarRelationFilter = {
    is?: datasetsWhereInput
    isNot?: datasetsWhereInput
  }

  export type ClustersListRelationFilter = {
    every?: clustersWhereInput
    some?: clustersWhereInput
    none?: clustersWhereInput
  }

  export type clustersOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type analysesCountOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    dataset_id?: SortOrder
    name?: SortOrder
    config?: SortOrder
    results?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type analysesMaxOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    dataset_id?: SortOrder
    name?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type analysesMinOrderByAggregateInput = {
    id?: SortOrder
    project_id?: SortOrder
    dataset_id?: SortOrder
    name?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type AnalysesScalarRelationFilter = {
    is?: analysesWhereInput
    isNot?: analysesWhereInput
  }

  export type clustersCountOrderByAggregateInput = {
    id?: SortOrder
    analysis_id?: SortOrder
    cluster_id?: SortOrder
    center_data?: SortOrder
    point_count?: SortOrder
    characteristics?: SortOrder
  }

  export type clustersAvgOrderByAggregateInput = {
    cluster_id?: SortOrder
    point_count?: SortOrder
  }

  export type clustersMaxOrderByAggregateInput = {
    id?: SortOrder
    analysis_id?: SortOrder
    cluster_id?: SortOrder
    point_count?: SortOrder
  }

  export type clustersMinOrderByAggregateInput = {
    id?: SortOrder
    analysis_id?: SortOrder
    cluster_id?: SortOrder
    point_count?: SortOrder
  }

  export type clustersSumOrderByAggregateInput = {
    cluster_id?: SortOrder
    point_count?: SortOrder
  }

  export type analysis_templatesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    config?: SortOrder
    user_id?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
  }

  export type analysis_templatesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    user_id?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
  }

  export type analysis_templatesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    user_id?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
  }

  export type usersCreateNestedOneWithoutProfileInput = {
    create?: XOR<usersCreateWithoutProfileInput, usersUncheckedCreateWithoutProfileInput>
    connectOrCreate?: usersCreateOrConnectWithoutProfileInput
    connect?: usersWhereUniqueInput
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type usersUpdateOneRequiredWithoutProfileNestedInput = {
    create?: XOR<usersCreateWithoutProfileInput, usersUncheckedCreateWithoutProfileInput>
    connectOrCreate?: usersCreateOrConnectWithoutProfileInput
    upsert?: usersUpsertWithoutProfileInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutProfileInput, usersUpdateWithoutProfileInput>, usersUncheckedUpdateWithoutProfileInput>
  }

  export type eventsCreateNestedManyWithoutUsersInput = {
    create?: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput> | eventsCreateWithoutUsersInput[] | eventsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: eventsCreateOrConnectWithoutUsersInput | eventsCreateOrConnectWithoutUsersInput[]
    createMany?: eventsCreateManyUsersInputEnvelope
    connect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
  }

  export type incident_logsCreateNestedManyWithoutUserInput = {
    create?: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput> | incident_logsCreateWithoutUserInput[] | incident_logsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutUserInput | incident_logsCreateOrConnectWithoutUserInput[]
    createMany?: incident_logsCreateManyUserInputEnvelope
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
  }

  export type panic_button_logsCreateNestedManyWithoutUsersInput = {
    create?: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput> | panic_button_logsCreateWithoutUsersInput[] | panic_button_logsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutUsersInput | panic_button_logsCreateOrConnectWithoutUsersInput[]
    createMany?: panic_button_logsCreateManyUsersInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type profilesCreateNestedOneWithoutUsersInput = {
    create?: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: profilesCreateOrConnectWithoutUsersInput
    connect?: profilesWhereUniqueInput
  }

  export type sessionsCreateNestedManyWithoutUserInput = {
    create?: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput> | sessionsCreateWithoutUserInput[] | sessionsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutUserInput | sessionsCreateOrConnectWithoutUserInput[]
    createMany?: sessionsCreateManyUserInputEnvelope
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
  }

  export type timelinesCreateNestedManyWithoutUserInput = {
    create?: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput> | timelinesCreateWithoutUserInput[] | timelinesUncheckedCreateWithoutUserInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutUserInput | timelinesCreateOrConnectWithoutUserInput[]
    createMany?: timelinesCreateManyUserInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type rolesCreateNestedOneWithoutUsersInput = {
    create?: XOR<rolesCreateWithoutUsersInput, rolesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: rolesCreateOrConnectWithoutUsersInput
    connect?: rolesWhereUniqueInput
  }

  export type taskCreateNestedManyWithoutUserInput = {
    create?: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput> | taskCreateWithoutUserInput[] | taskUncheckedCreateWithoutUserInput[]
    connectOrCreate?: taskCreateOrConnectWithoutUserInput | taskCreateOrConnectWithoutUserInput[]
    createMany?: taskCreateManyUserInputEnvelope
    connect?: taskWhereUniqueInput | taskWhereUniqueInput[]
  }

  export type messagesCreateNestedManyWithoutSender_userInput = {
    create?: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput> | messagesCreateWithoutSender_userInput[] | messagesUncheckedCreateWithoutSender_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_userInput | messagesCreateOrConnectWithoutSender_userInput[]
    createMany?: messagesCreateManySender_userInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type messagesCreateNestedManyWithoutRecipient_userInput = {
    create?: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput> | messagesCreateWithoutRecipient_userInput[] | messagesUncheckedCreateWithoutRecipient_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_userInput | messagesCreateOrConnectWithoutRecipient_userInput[]
    createMany?: messagesCreateManyRecipient_userInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type projectsCreateNestedManyWithoutUsersInput = {
    create?: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput> | projectsCreateWithoutUsersInput[] | projectsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: projectsCreateOrConnectWithoutUsersInput | projectsCreateOrConnectWithoutUsersInput[]
    createMany?: projectsCreateManyUsersInputEnvelope
    connect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
  }

  export type inboxCreateNestedOneWithoutUserInput = {
    create?: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
    connectOrCreate?: inboxCreateOrConnectWithoutUserInput
    connect?: inboxWhereUniqueInput
  }

  export type eventsUncheckedCreateNestedManyWithoutUsersInput = {
    create?: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput> | eventsCreateWithoutUsersInput[] | eventsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: eventsCreateOrConnectWithoutUsersInput | eventsCreateOrConnectWithoutUsersInput[]
    createMany?: eventsCreateManyUsersInputEnvelope
    connect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
  }

  export type incident_logsUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput> | incident_logsCreateWithoutUserInput[] | incident_logsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutUserInput | incident_logsCreateOrConnectWithoutUserInput[]
    createMany?: incident_logsCreateManyUserInputEnvelope
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
  }

  export type panic_button_logsUncheckedCreateNestedManyWithoutUsersInput = {
    create?: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput> | panic_button_logsCreateWithoutUsersInput[] | panic_button_logsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutUsersInput | panic_button_logsCreateOrConnectWithoutUsersInput[]
    createMany?: panic_button_logsCreateManyUsersInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type profilesUncheckedCreateNestedOneWithoutUsersInput = {
    create?: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: profilesCreateOrConnectWithoutUsersInput
    connect?: profilesWhereUniqueInput
  }

  export type sessionsUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput> | sessionsCreateWithoutUserInput[] | sessionsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutUserInput | sessionsCreateOrConnectWithoutUserInput[]
    createMany?: sessionsCreateManyUserInputEnvelope
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
  }

  export type timelinesUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput> | timelinesCreateWithoutUserInput[] | timelinesUncheckedCreateWithoutUserInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutUserInput | timelinesCreateOrConnectWithoutUserInput[]
    createMany?: timelinesCreateManyUserInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type taskUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput> | taskCreateWithoutUserInput[] | taskUncheckedCreateWithoutUserInput[]
    connectOrCreate?: taskCreateOrConnectWithoutUserInput | taskCreateOrConnectWithoutUserInput[]
    createMany?: taskCreateManyUserInputEnvelope
    connect?: taskWhereUniqueInput | taskWhereUniqueInput[]
  }

  export type messagesUncheckedCreateNestedManyWithoutSender_userInput = {
    create?: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput> | messagesCreateWithoutSender_userInput[] | messagesUncheckedCreateWithoutSender_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_userInput | messagesCreateOrConnectWithoutSender_userInput[]
    createMany?: messagesCreateManySender_userInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type messagesUncheckedCreateNestedManyWithoutRecipient_userInput = {
    create?: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput> | messagesCreateWithoutRecipient_userInput[] | messagesUncheckedCreateWithoutRecipient_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_userInput | messagesCreateOrConnectWithoutRecipient_userInput[]
    createMany?: messagesCreateManyRecipient_userInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type projectsUncheckedCreateNestedManyWithoutUsersInput = {
    create?: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput> | projectsCreateWithoutUsersInput[] | projectsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: projectsCreateOrConnectWithoutUsersInput | projectsCreateOrConnectWithoutUsersInput[]
    createMany?: projectsCreateManyUsersInputEnvelope
    connect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
  }

  export type inboxUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
    connectOrCreate?: inboxCreateOrConnectWithoutUserInput
    connect?: inboxWhereUniqueInput
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type eventsUpdateManyWithoutUsersNestedInput = {
    create?: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput> | eventsCreateWithoutUsersInput[] | eventsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: eventsCreateOrConnectWithoutUsersInput | eventsCreateOrConnectWithoutUsersInput[]
    upsert?: eventsUpsertWithWhereUniqueWithoutUsersInput | eventsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: eventsCreateManyUsersInputEnvelope
    set?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    disconnect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    delete?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    connect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    update?: eventsUpdateWithWhereUniqueWithoutUsersInput | eventsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: eventsUpdateManyWithWhereWithoutUsersInput | eventsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: eventsScalarWhereInput | eventsScalarWhereInput[]
  }

  export type incident_logsUpdateManyWithoutUserNestedInput = {
    create?: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput> | incident_logsCreateWithoutUserInput[] | incident_logsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutUserInput | incident_logsCreateOrConnectWithoutUserInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutUserInput | incident_logsUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: incident_logsCreateManyUserInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutUserInput | incident_logsUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutUserInput | incident_logsUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type panic_button_logsUpdateManyWithoutUsersNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput> | panic_button_logsCreateWithoutUsersInput[] | panic_button_logsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutUsersInput | panic_button_logsCreateOrConnectWithoutUsersInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutUsersInput | panic_button_logsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: panic_button_logsCreateManyUsersInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutUsersInput | panic_button_logsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutUsersInput | panic_button_logsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type profilesUpdateOneWithoutUsersNestedInput = {
    create?: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: profilesCreateOrConnectWithoutUsersInput
    upsert?: profilesUpsertWithoutUsersInput
    disconnect?: profilesWhereInput | boolean
    delete?: profilesWhereInput | boolean
    connect?: profilesWhereUniqueInput
    update?: XOR<XOR<profilesUpdateToOneWithWhereWithoutUsersInput, profilesUpdateWithoutUsersInput>, profilesUncheckedUpdateWithoutUsersInput>
  }

  export type sessionsUpdateManyWithoutUserNestedInput = {
    create?: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput> | sessionsCreateWithoutUserInput[] | sessionsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutUserInput | sessionsCreateOrConnectWithoutUserInput[]
    upsert?: sessionsUpsertWithWhereUniqueWithoutUserInput | sessionsUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: sessionsCreateManyUserInputEnvelope
    set?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    disconnect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    delete?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    update?: sessionsUpdateWithWhereUniqueWithoutUserInput | sessionsUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: sessionsUpdateManyWithWhereWithoutUserInput | sessionsUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
  }

  export type timelinesUpdateManyWithoutUserNestedInput = {
    create?: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput> | timelinesCreateWithoutUserInput[] | timelinesUncheckedCreateWithoutUserInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutUserInput | timelinesCreateOrConnectWithoutUserInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutUserInput | timelinesUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: timelinesCreateManyUserInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutUserInput | timelinesUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutUserInput | timelinesUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type rolesUpdateOneRequiredWithoutUsersNestedInput = {
    create?: XOR<rolesCreateWithoutUsersInput, rolesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: rolesCreateOrConnectWithoutUsersInput
    upsert?: rolesUpsertWithoutUsersInput
    connect?: rolesWhereUniqueInput
    update?: XOR<XOR<rolesUpdateToOneWithWhereWithoutUsersInput, rolesUpdateWithoutUsersInput>, rolesUncheckedUpdateWithoutUsersInput>
  }

  export type taskUpdateManyWithoutUserNestedInput = {
    create?: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput> | taskCreateWithoutUserInput[] | taskUncheckedCreateWithoutUserInput[]
    connectOrCreate?: taskCreateOrConnectWithoutUserInput | taskCreateOrConnectWithoutUserInput[]
    upsert?: taskUpsertWithWhereUniqueWithoutUserInput | taskUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: taskCreateManyUserInputEnvelope
    set?: taskWhereUniqueInput | taskWhereUniqueInput[]
    disconnect?: taskWhereUniqueInput | taskWhereUniqueInput[]
    delete?: taskWhereUniqueInput | taskWhereUniqueInput[]
    connect?: taskWhereUniqueInput | taskWhereUniqueInput[]
    update?: taskUpdateWithWhereUniqueWithoutUserInput | taskUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: taskUpdateManyWithWhereWithoutUserInput | taskUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: taskScalarWhereInput | taskScalarWhereInput[]
  }

  export type messagesUpdateManyWithoutSender_userNestedInput = {
    create?: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput> | messagesCreateWithoutSender_userInput[] | messagesUncheckedCreateWithoutSender_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_userInput | messagesCreateOrConnectWithoutSender_userInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutSender_userInput | messagesUpsertWithWhereUniqueWithoutSender_userInput[]
    createMany?: messagesCreateManySender_userInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutSender_userInput | messagesUpdateWithWhereUniqueWithoutSender_userInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutSender_userInput | messagesUpdateManyWithWhereWithoutSender_userInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type messagesUpdateManyWithoutRecipient_userNestedInput = {
    create?: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput> | messagesCreateWithoutRecipient_userInput[] | messagesUncheckedCreateWithoutRecipient_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_userInput | messagesCreateOrConnectWithoutRecipient_userInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutRecipient_userInput | messagesUpsertWithWhereUniqueWithoutRecipient_userInput[]
    createMany?: messagesCreateManyRecipient_userInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutRecipient_userInput | messagesUpdateWithWhereUniqueWithoutRecipient_userInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutRecipient_userInput | messagesUpdateManyWithWhereWithoutRecipient_userInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type projectsUpdateManyWithoutUsersNestedInput = {
    create?: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput> | projectsCreateWithoutUsersInput[] | projectsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: projectsCreateOrConnectWithoutUsersInput | projectsCreateOrConnectWithoutUsersInput[]
    upsert?: projectsUpsertWithWhereUniqueWithoutUsersInput | projectsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: projectsCreateManyUsersInputEnvelope
    set?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    disconnect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    delete?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    connect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    update?: projectsUpdateWithWhereUniqueWithoutUsersInput | projectsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: projectsUpdateManyWithWhereWithoutUsersInput | projectsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: projectsScalarWhereInput | projectsScalarWhereInput[]
  }

  export type inboxUpdateOneWithoutUserNestedInput = {
    create?: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
    connectOrCreate?: inboxCreateOrConnectWithoutUserInput
    upsert?: inboxUpsertWithoutUserInput
    disconnect?: inboxWhereInput | boolean
    delete?: inboxWhereInput | boolean
    connect?: inboxWhereUniqueInput
    update?: XOR<XOR<inboxUpdateToOneWithWhereWithoutUserInput, inboxUpdateWithoutUserInput>, inboxUncheckedUpdateWithoutUserInput>
  }

  export type eventsUncheckedUpdateManyWithoutUsersNestedInput = {
    create?: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput> | eventsCreateWithoutUsersInput[] | eventsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: eventsCreateOrConnectWithoutUsersInput | eventsCreateOrConnectWithoutUsersInput[]
    upsert?: eventsUpsertWithWhereUniqueWithoutUsersInput | eventsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: eventsCreateManyUsersInputEnvelope
    set?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    disconnect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    delete?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    connect?: eventsWhereUniqueInput | eventsWhereUniqueInput[]
    update?: eventsUpdateWithWhereUniqueWithoutUsersInput | eventsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: eventsUpdateManyWithWhereWithoutUsersInput | eventsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: eventsScalarWhereInput | eventsScalarWhereInput[]
  }

  export type incident_logsUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput> | incident_logsCreateWithoutUserInput[] | incident_logsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutUserInput | incident_logsCreateOrConnectWithoutUserInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutUserInput | incident_logsUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: incident_logsCreateManyUserInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutUserInput | incident_logsUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutUserInput | incident_logsUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput> | panic_button_logsCreateWithoutUsersInput[] | panic_button_logsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutUsersInput | panic_button_logsCreateOrConnectWithoutUsersInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutUsersInput | panic_button_logsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: panic_button_logsCreateManyUsersInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutUsersInput | panic_button_logsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutUsersInput | panic_button_logsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type profilesUncheckedUpdateOneWithoutUsersNestedInput = {
    create?: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
    connectOrCreate?: profilesCreateOrConnectWithoutUsersInput
    upsert?: profilesUpsertWithoutUsersInput
    disconnect?: profilesWhereInput | boolean
    delete?: profilesWhereInput | boolean
    connect?: profilesWhereUniqueInput
    update?: XOR<XOR<profilesUpdateToOneWithWhereWithoutUsersInput, profilesUpdateWithoutUsersInput>, profilesUncheckedUpdateWithoutUsersInput>
  }

  export type sessionsUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput> | sessionsCreateWithoutUserInput[] | sessionsUncheckedCreateWithoutUserInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutUserInput | sessionsCreateOrConnectWithoutUserInput[]
    upsert?: sessionsUpsertWithWhereUniqueWithoutUserInput | sessionsUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: sessionsCreateManyUserInputEnvelope
    set?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    disconnect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    delete?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    update?: sessionsUpdateWithWhereUniqueWithoutUserInput | sessionsUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: sessionsUpdateManyWithWhereWithoutUserInput | sessionsUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
  }

  export type timelinesUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput> | timelinesCreateWithoutUserInput[] | timelinesUncheckedCreateWithoutUserInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutUserInput | timelinesCreateOrConnectWithoutUserInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutUserInput | timelinesUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: timelinesCreateManyUserInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutUserInput | timelinesUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutUserInput | timelinesUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type taskUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput> | taskCreateWithoutUserInput[] | taskUncheckedCreateWithoutUserInput[]
    connectOrCreate?: taskCreateOrConnectWithoutUserInput | taskCreateOrConnectWithoutUserInput[]
    upsert?: taskUpsertWithWhereUniqueWithoutUserInput | taskUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: taskCreateManyUserInputEnvelope
    set?: taskWhereUniqueInput | taskWhereUniqueInput[]
    disconnect?: taskWhereUniqueInput | taskWhereUniqueInput[]
    delete?: taskWhereUniqueInput | taskWhereUniqueInput[]
    connect?: taskWhereUniqueInput | taskWhereUniqueInput[]
    update?: taskUpdateWithWhereUniqueWithoutUserInput | taskUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: taskUpdateManyWithWhereWithoutUserInput | taskUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: taskScalarWhereInput | taskScalarWhereInput[]
  }

  export type messagesUncheckedUpdateManyWithoutSender_userNestedInput = {
    create?: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput> | messagesCreateWithoutSender_userInput[] | messagesUncheckedCreateWithoutSender_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_userInput | messagesCreateOrConnectWithoutSender_userInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutSender_userInput | messagesUpsertWithWhereUniqueWithoutSender_userInput[]
    createMany?: messagesCreateManySender_userInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutSender_userInput | messagesUpdateWithWhereUniqueWithoutSender_userInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutSender_userInput | messagesUpdateManyWithWhereWithoutSender_userInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type messagesUncheckedUpdateManyWithoutRecipient_userNestedInput = {
    create?: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput> | messagesCreateWithoutRecipient_userInput[] | messagesUncheckedCreateWithoutRecipient_userInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_userInput | messagesCreateOrConnectWithoutRecipient_userInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutRecipient_userInput | messagesUpsertWithWhereUniqueWithoutRecipient_userInput[]
    createMany?: messagesCreateManyRecipient_userInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutRecipient_userInput | messagesUpdateWithWhereUniqueWithoutRecipient_userInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutRecipient_userInput | messagesUpdateManyWithWhereWithoutRecipient_userInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type projectsUncheckedUpdateManyWithoutUsersNestedInput = {
    create?: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput> | projectsCreateWithoutUsersInput[] | projectsUncheckedCreateWithoutUsersInput[]
    connectOrCreate?: projectsCreateOrConnectWithoutUsersInput | projectsCreateOrConnectWithoutUsersInput[]
    upsert?: projectsUpsertWithWhereUniqueWithoutUsersInput | projectsUpsertWithWhereUniqueWithoutUsersInput[]
    createMany?: projectsCreateManyUsersInputEnvelope
    set?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    disconnect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    delete?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    connect?: projectsWhereUniqueInput | projectsWhereUniqueInput[]
    update?: projectsUpdateWithWhereUniqueWithoutUsersInput | projectsUpdateWithWhereUniqueWithoutUsersInput[]
    updateMany?: projectsUpdateManyWithWhereWithoutUsersInput | projectsUpdateManyWithWhereWithoutUsersInput[]
    deleteMany?: projectsScalarWhereInput | projectsScalarWhereInput[]
  }

  export type inboxUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
    connectOrCreate?: inboxCreateOrConnectWithoutUserInput
    upsert?: inboxUpsertWithoutUserInput
    disconnect?: inboxWhereInput | boolean
    delete?: inboxWhereInput | boolean
    connect?: inboxWhereUniqueInput
    update?: XOR<XOR<inboxUpdateToOneWithWhereWithoutUserInput, inboxUpdateWithoutUserInput>, inboxUncheckedUpdateWithoutUserInput>
  }

  export type officersCreateNestedManyWithoutRolesInput = {
    create?: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput> | officersCreateWithoutRolesInput[] | officersUncheckedCreateWithoutRolesInput[]
    connectOrCreate?: officersCreateOrConnectWithoutRolesInput | officersCreateOrConnectWithoutRolesInput[]
    createMany?: officersCreateManyRolesInputEnvelope
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
  }

  export type permissionsCreateNestedManyWithoutRoleInput = {
    create?: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput> | permissionsCreateWithoutRoleInput[] | permissionsUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutRoleInput | permissionsCreateOrConnectWithoutRoleInput[]
    createMany?: permissionsCreateManyRoleInputEnvelope
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
  }

  export type usersCreateNestedManyWithoutRoleInput = {
    create?: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput> | usersCreateWithoutRoleInput[] | usersUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: usersCreateOrConnectWithoutRoleInput | usersCreateOrConnectWithoutRoleInput[]
    createMany?: usersCreateManyRoleInputEnvelope
    connect?: usersWhereUniqueInput | usersWhereUniqueInput[]
  }

  export type officersUncheckedCreateNestedManyWithoutRolesInput = {
    create?: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput> | officersCreateWithoutRolesInput[] | officersUncheckedCreateWithoutRolesInput[]
    connectOrCreate?: officersCreateOrConnectWithoutRolesInput | officersCreateOrConnectWithoutRolesInput[]
    createMany?: officersCreateManyRolesInputEnvelope
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
  }

  export type permissionsUncheckedCreateNestedManyWithoutRoleInput = {
    create?: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput> | permissionsCreateWithoutRoleInput[] | permissionsUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutRoleInput | permissionsCreateOrConnectWithoutRoleInput[]
    createMany?: permissionsCreateManyRoleInputEnvelope
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
  }

  export type usersUncheckedCreateNestedManyWithoutRoleInput = {
    create?: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput> | usersCreateWithoutRoleInput[] | usersUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: usersCreateOrConnectWithoutRoleInput | usersCreateOrConnectWithoutRoleInput[]
    createMany?: usersCreateManyRoleInputEnvelope
    connect?: usersWhereUniqueInput | usersWhereUniqueInput[]
  }

  export type officersUpdateManyWithoutRolesNestedInput = {
    create?: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput> | officersCreateWithoutRolesInput[] | officersUncheckedCreateWithoutRolesInput[]
    connectOrCreate?: officersCreateOrConnectWithoutRolesInput | officersCreateOrConnectWithoutRolesInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutRolesInput | officersUpsertWithWhereUniqueWithoutRolesInput[]
    createMany?: officersCreateManyRolesInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutRolesInput | officersUpdateWithWhereUniqueWithoutRolesInput[]
    updateMany?: officersUpdateManyWithWhereWithoutRolesInput | officersUpdateManyWithWhereWithoutRolesInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type permissionsUpdateManyWithoutRoleNestedInput = {
    create?: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput> | permissionsCreateWithoutRoleInput[] | permissionsUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutRoleInput | permissionsCreateOrConnectWithoutRoleInput[]
    upsert?: permissionsUpsertWithWhereUniqueWithoutRoleInput | permissionsUpsertWithWhereUniqueWithoutRoleInput[]
    createMany?: permissionsCreateManyRoleInputEnvelope
    set?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    disconnect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    delete?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    update?: permissionsUpdateWithWhereUniqueWithoutRoleInput | permissionsUpdateWithWhereUniqueWithoutRoleInput[]
    updateMany?: permissionsUpdateManyWithWhereWithoutRoleInput | permissionsUpdateManyWithWhereWithoutRoleInput[]
    deleteMany?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
  }

  export type usersUpdateManyWithoutRoleNestedInput = {
    create?: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput> | usersCreateWithoutRoleInput[] | usersUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: usersCreateOrConnectWithoutRoleInput | usersCreateOrConnectWithoutRoleInput[]
    upsert?: usersUpsertWithWhereUniqueWithoutRoleInput | usersUpsertWithWhereUniqueWithoutRoleInput[]
    createMany?: usersCreateManyRoleInputEnvelope
    set?: usersWhereUniqueInput | usersWhereUniqueInput[]
    disconnect?: usersWhereUniqueInput | usersWhereUniqueInput[]
    delete?: usersWhereUniqueInput | usersWhereUniqueInput[]
    connect?: usersWhereUniqueInput | usersWhereUniqueInput[]
    update?: usersUpdateWithWhereUniqueWithoutRoleInput | usersUpdateWithWhereUniqueWithoutRoleInput[]
    updateMany?: usersUpdateManyWithWhereWithoutRoleInput | usersUpdateManyWithWhereWithoutRoleInput[]
    deleteMany?: usersScalarWhereInput | usersScalarWhereInput[]
  }

  export type officersUncheckedUpdateManyWithoutRolesNestedInput = {
    create?: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput> | officersCreateWithoutRolesInput[] | officersUncheckedCreateWithoutRolesInput[]
    connectOrCreate?: officersCreateOrConnectWithoutRolesInput | officersCreateOrConnectWithoutRolesInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutRolesInput | officersUpsertWithWhereUniqueWithoutRolesInput[]
    createMany?: officersCreateManyRolesInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutRolesInput | officersUpdateWithWhereUniqueWithoutRolesInput[]
    updateMany?: officersUpdateManyWithWhereWithoutRolesInput | officersUpdateManyWithWhereWithoutRolesInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type permissionsUncheckedUpdateManyWithoutRoleNestedInput = {
    create?: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput> | permissionsCreateWithoutRoleInput[] | permissionsUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutRoleInput | permissionsCreateOrConnectWithoutRoleInput[]
    upsert?: permissionsUpsertWithWhereUniqueWithoutRoleInput | permissionsUpsertWithWhereUniqueWithoutRoleInput[]
    createMany?: permissionsCreateManyRoleInputEnvelope
    set?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    disconnect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    delete?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    update?: permissionsUpdateWithWhereUniqueWithoutRoleInput | permissionsUpdateWithWhereUniqueWithoutRoleInput[]
    updateMany?: permissionsUpdateManyWithWhereWithoutRoleInput | permissionsUpdateManyWithWhereWithoutRoleInput[]
    deleteMany?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
  }

  export type usersUncheckedUpdateManyWithoutRoleNestedInput = {
    create?: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput> | usersCreateWithoutRoleInput[] | usersUncheckedCreateWithoutRoleInput[]
    connectOrCreate?: usersCreateOrConnectWithoutRoleInput | usersCreateOrConnectWithoutRoleInput[]
    upsert?: usersUpsertWithWhereUniqueWithoutRoleInput | usersUpsertWithWhereUniqueWithoutRoleInput[]
    createMany?: usersCreateManyRoleInputEnvelope
    set?: usersWhereUniqueInput | usersWhereUniqueInput[]
    disconnect?: usersWhereUniqueInput | usersWhereUniqueInput[]
    delete?: usersWhereUniqueInput | usersWhereUniqueInput[]
    connect?: usersWhereUniqueInput | usersWhereUniqueInput[]
    update?: usersUpdateWithWhereUniqueWithoutRoleInput | usersUpdateWithWhereUniqueWithoutRoleInput[]
    updateMany?: usersUpdateManyWithWhereWithoutRoleInput | usersUpdateManyWithWhereWithoutRoleInput[]
    deleteMany?: usersScalarWhereInput | usersScalarWhereInput[]
  }

  export type eventsCreateNestedOneWithoutSessionsInput = {
    create?: XOR<eventsCreateWithoutSessionsInput, eventsUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: eventsCreateOrConnectWithoutSessionsInput
    connect?: eventsWhereUniqueInput
  }

  export type usersCreateNestedOneWithoutSessionsInput = {
    create?: XOR<usersCreateWithoutSessionsInput, usersUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: usersCreateOrConnectWithoutSessionsInput
    connect?: usersWhereUniqueInput
  }

  export type Enumsession_statusFieldUpdateOperationsInput = {
    set?: $Enums.session_status
  }

  export type eventsUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<eventsCreateWithoutSessionsInput, eventsUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: eventsCreateOrConnectWithoutSessionsInput
    upsert?: eventsUpsertWithoutSessionsInput
    connect?: eventsWhereUniqueInput
    update?: XOR<XOR<eventsUpdateToOneWithWhereWithoutSessionsInput, eventsUpdateWithoutSessionsInput>, eventsUncheckedUpdateWithoutSessionsInput>
  }

  export type usersUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<usersCreateWithoutSessionsInput, usersUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: usersCreateOrConnectWithoutSessionsInput
    upsert?: usersUpsertWithoutSessionsInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutSessionsInput, usersUpdateWithoutSessionsInput>, usersUncheckedUpdateWithoutSessionsInput>
  }

  export type usersCreateNestedOneWithoutEventsInput = {
    create?: XOR<usersCreateWithoutEventsInput, usersUncheckedCreateWithoutEventsInput>
    connectOrCreate?: usersCreateOrConnectWithoutEventsInput
    connect?: usersWhereUniqueInput
  }

  export type locationsCreateNestedManyWithoutEventInput = {
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
  }

  export type sessionsCreateNestedManyWithoutEventInput = {
    create?: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput> | sessionsCreateWithoutEventInput[] | sessionsUncheckedCreateWithoutEventInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutEventInput | sessionsCreateOrConnectWithoutEventInput[]
    createMany?: sessionsCreateManyEventInputEnvelope
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
  }

  export type locationsUncheckedCreateNestedManyWithoutEventInput = {
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
  }

  export type sessionsUncheckedCreateNestedManyWithoutEventInput = {
    create?: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput> | sessionsCreateWithoutEventInput[] | sessionsUncheckedCreateWithoutEventInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutEventInput | sessionsCreateOrConnectWithoutEventInput[]
    createMany?: sessionsCreateManyEventInputEnvelope
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
  }

  export type usersUpdateOneRequiredWithoutEventsNestedInput = {
    create?: XOR<usersCreateWithoutEventsInput, usersUncheckedCreateWithoutEventsInput>
    connectOrCreate?: usersCreateOrConnectWithoutEventsInput
    upsert?: usersUpsertWithoutEventsInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutEventsInput, usersUpdateWithoutEventsInput>, usersUncheckedUpdateWithoutEventsInput>
  }

  export type locationsUpdateManyWithoutEventNestedInput = {
    set?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    disconnect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    delete?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    update?: locationsUpdateWithWhereUniqueWithoutEventInput | locationsUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: locationsUpdateManyWithWhereWithoutEventInput | locationsUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: locationsScalarWhereInput | locationsScalarWhereInput[]
  }

  export type sessionsUpdateManyWithoutEventNestedInput = {
    create?: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput> | sessionsCreateWithoutEventInput[] | sessionsUncheckedCreateWithoutEventInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutEventInput | sessionsCreateOrConnectWithoutEventInput[]
    upsert?: sessionsUpsertWithWhereUniqueWithoutEventInput | sessionsUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: sessionsCreateManyEventInputEnvelope
    set?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    disconnect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    delete?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    update?: sessionsUpdateWithWhereUniqueWithoutEventInput | sessionsUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: sessionsUpdateManyWithWhereWithoutEventInput | sessionsUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
  }

  export type locationsUncheckedUpdateManyWithoutEventNestedInput = {
    set?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    disconnect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    delete?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    update?: locationsUpdateWithWhereUniqueWithoutEventInput | locationsUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: locationsUpdateManyWithWhereWithoutEventInput | locationsUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: locationsScalarWhereInput | locationsScalarWhereInput[]
  }

  export type sessionsUncheckedUpdateManyWithoutEventNestedInput = {
    create?: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput> | sessionsCreateWithoutEventInput[] | sessionsUncheckedCreateWithoutEventInput[]
    connectOrCreate?: sessionsCreateOrConnectWithoutEventInput | sessionsCreateOrConnectWithoutEventInput[]
    upsert?: sessionsUpsertWithWhereUniqueWithoutEventInput | sessionsUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: sessionsCreateManyEventInputEnvelope
    set?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    disconnect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    delete?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    connect?: sessionsWhereUniqueInput | sessionsWhereUniqueInput[]
    update?: sessionsUpdateWithWhereUniqueWithoutEventInput | sessionsUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: sessionsUpdateManyWithWhereWithoutEventInput | sessionsUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
  }

  export type permissionsCreateNestedManyWithoutResourceInput = {
    create?: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput> | permissionsCreateWithoutResourceInput[] | permissionsUncheckedCreateWithoutResourceInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutResourceInput | permissionsCreateOrConnectWithoutResourceInput[]
    createMany?: permissionsCreateManyResourceInputEnvelope
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
  }

  export type permissionsUncheckedCreateNestedManyWithoutResourceInput = {
    create?: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput> | permissionsCreateWithoutResourceInput[] | permissionsUncheckedCreateWithoutResourceInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutResourceInput | permissionsCreateOrConnectWithoutResourceInput[]
    createMany?: permissionsCreateManyResourceInputEnvelope
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
  }

  export type permissionsUpdateManyWithoutResourceNestedInput = {
    create?: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput> | permissionsCreateWithoutResourceInput[] | permissionsUncheckedCreateWithoutResourceInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutResourceInput | permissionsCreateOrConnectWithoutResourceInput[]
    upsert?: permissionsUpsertWithWhereUniqueWithoutResourceInput | permissionsUpsertWithWhereUniqueWithoutResourceInput[]
    createMany?: permissionsCreateManyResourceInputEnvelope
    set?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    disconnect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    delete?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    update?: permissionsUpdateWithWhereUniqueWithoutResourceInput | permissionsUpdateWithWhereUniqueWithoutResourceInput[]
    updateMany?: permissionsUpdateManyWithWhereWithoutResourceInput | permissionsUpdateManyWithWhereWithoutResourceInput[]
    deleteMany?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
  }

  export type permissionsUncheckedUpdateManyWithoutResourceNestedInput = {
    create?: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput> | permissionsCreateWithoutResourceInput[] | permissionsUncheckedCreateWithoutResourceInput[]
    connectOrCreate?: permissionsCreateOrConnectWithoutResourceInput | permissionsCreateOrConnectWithoutResourceInput[]
    upsert?: permissionsUpsertWithWhereUniqueWithoutResourceInput | permissionsUpsertWithWhereUniqueWithoutResourceInput[]
    createMany?: permissionsCreateManyResourceInputEnvelope
    set?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    disconnect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    delete?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    connect?: permissionsWhereUniqueInput | permissionsWhereUniqueInput[]
    update?: permissionsUpdateWithWhereUniqueWithoutResourceInput | permissionsUpdateWithWhereUniqueWithoutResourceInput[]
    updateMany?: permissionsUpdateManyWithWhereWithoutResourceInput | permissionsUpdateManyWithWhereWithoutResourceInput[]
    deleteMany?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
  }

  export type resourcesCreateNestedOneWithoutPermissionsInput = {
    create?: XOR<resourcesCreateWithoutPermissionsInput, resourcesUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: resourcesCreateOrConnectWithoutPermissionsInput
    connect?: resourcesWhereUniqueInput
  }

  export type rolesCreateNestedOneWithoutPermissionsInput = {
    create?: XOR<rolesCreateWithoutPermissionsInput, rolesUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: rolesCreateOrConnectWithoutPermissionsInput
    connect?: rolesWhereUniqueInput
  }

  export type resourcesUpdateOneRequiredWithoutPermissionsNestedInput = {
    create?: XOR<resourcesCreateWithoutPermissionsInput, resourcesUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: resourcesCreateOrConnectWithoutPermissionsInput
    upsert?: resourcesUpsertWithoutPermissionsInput
    connect?: resourcesWhereUniqueInput
    update?: XOR<XOR<resourcesUpdateToOneWithWhereWithoutPermissionsInput, resourcesUpdateWithoutPermissionsInput>, resourcesUncheckedUpdateWithoutPermissionsInput>
  }

  export type rolesUpdateOneRequiredWithoutPermissionsNestedInput = {
    create?: XOR<rolesCreateWithoutPermissionsInput, rolesUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: rolesCreateOrConnectWithoutPermissionsInput
    upsert?: rolesUpsertWithoutPermissionsInput
    connect?: rolesWhereUniqueInput
    update?: XOR<XOR<rolesUpdateToOneWithWhereWithoutPermissionsInput, rolesUpdateWithoutPermissionsInput>, rolesUncheckedUpdateWithoutPermissionsInput>
  }

  export type districtsCreateNestedManyWithoutCitiesInput = {
    create?: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput> | districtsCreateWithoutCitiesInput[] | districtsUncheckedCreateWithoutCitiesInput[]
    connectOrCreate?: districtsCreateOrConnectWithoutCitiesInput | districtsCreateOrConnectWithoutCitiesInput[]
    createMany?: districtsCreateManyCitiesInputEnvelope
    connect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
  }

  export type unitsCreateNestedManyWithoutCitiesInput = {
    connect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
  }

  export type districtsUncheckedCreateNestedManyWithoutCitiesInput = {
    create?: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput> | districtsCreateWithoutCitiesInput[] | districtsUncheckedCreateWithoutCitiesInput[]
    connectOrCreate?: districtsCreateOrConnectWithoutCitiesInput | districtsCreateOrConnectWithoutCitiesInput[]
    createMany?: districtsCreateManyCitiesInputEnvelope
    connect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
  }

  export type unitsUncheckedCreateNestedManyWithoutCitiesInput = {
    connect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
  }

  export type districtsUpdateManyWithoutCitiesNestedInput = {
    create?: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput> | districtsCreateWithoutCitiesInput[] | districtsUncheckedCreateWithoutCitiesInput[]
    connectOrCreate?: districtsCreateOrConnectWithoutCitiesInput | districtsCreateOrConnectWithoutCitiesInput[]
    upsert?: districtsUpsertWithWhereUniqueWithoutCitiesInput | districtsUpsertWithWhereUniqueWithoutCitiesInput[]
    createMany?: districtsCreateManyCitiesInputEnvelope
    set?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    disconnect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    delete?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    connect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    update?: districtsUpdateWithWhereUniqueWithoutCitiesInput | districtsUpdateWithWhereUniqueWithoutCitiesInput[]
    updateMany?: districtsUpdateManyWithWhereWithoutCitiesInput | districtsUpdateManyWithWhereWithoutCitiesInput[]
    deleteMany?: districtsScalarWhereInput | districtsScalarWhereInput[]
  }

  export type unitsUpdateManyWithoutCitiesNestedInput = {
    set?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    disconnect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    delete?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    connect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    update?: unitsUpdateWithWhereUniqueWithoutCitiesInput | unitsUpdateWithWhereUniqueWithoutCitiesInput[]
    updateMany?: unitsUpdateManyWithWhereWithoutCitiesInput | unitsUpdateManyWithWhereWithoutCitiesInput[]
    deleteMany?: unitsScalarWhereInput | unitsScalarWhereInput[]
  }

  export type districtsUncheckedUpdateManyWithoutCitiesNestedInput = {
    create?: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput> | districtsCreateWithoutCitiesInput[] | districtsUncheckedCreateWithoutCitiesInput[]
    connectOrCreate?: districtsCreateOrConnectWithoutCitiesInput | districtsCreateOrConnectWithoutCitiesInput[]
    upsert?: districtsUpsertWithWhereUniqueWithoutCitiesInput | districtsUpsertWithWhereUniqueWithoutCitiesInput[]
    createMany?: districtsCreateManyCitiesInputEnvelope
    set?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    disconnect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    delete?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    connect?: districtsWhereUniqueInput | districtsWhereUniqueInput[]
    update?: districtsUpdateWithWhereUniqueWithoutCitiesInput | districtsUpdateWithWhereUniqueWithoutCitiesInput[]
    updateMany?: districtsUpdateManyWithWhereWithoutCitiesInput | districtsUpdateManyWithWhereWithoutCitiesInput[]
    deleteMany?: districtsScalarWhereInput | districtsScalarWhereInput[]
  }

  export type unitsUncheckedUpdateManyWithoutCitiesNestedInput = {
    set?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    disconnect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    delete?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    connect?: unitsWhereUniqueInput | unitsWhereUniqueInput[]
    update?: unitsUpdateWithWhereUniqueWithoutCitiesInput | unitsUpdateWithWhereUniqueWithoutCitiesInput[]
    updateMany?: unitsUpdateManyWithWhereWithoutCitiesInput | unitsUpdateManyWithWhereWithoutCitiesInput[]
    deleteMany?: unitsScalarWhereInput | unitsScalarWhereInput[]
  }

  export type crime_categoriesCreateNestedOneWithoutCrime_incidentsInput = {
    create?: XOR<crime_categoriesCreateWithoutCrime_incidentsInput, crime_categoriesUncheckedCreateWithoutCrime_incidentsInput>
    connectOrCreate?: crime_categoriesCreateOrConnectWithoutCrime_incidentsInput
    connect?: crime_categoriesWhereUniqueInput
  }

  export type crimesCreateNestedOneWithoutCrime_incidentsInput = {
    create?: XOR<crimesCreateWithoutCrime_incidentsInput, crimesUncheckedCreateWithoutCrime_incidentsInput>
    connectOrCreate?: crimesCreateOrConnectWithoutCrime_incidentsInput
    connect?: crimesWhereUniqueInput
  }

  export type locationsCreateNestedOneWithoutCrime_incidentsInput = {
    connect?: locationsWhereUniqueInput
  }

  export type evidenceCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput> | evidenceCreateWithoutCrime_incidentsInput[] | evidenceUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutCrime_incidentsInput | evidenceCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: evidenceCreateManyCrime_incidentsInputEnvelope
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
  }

  export type timelinesCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput> | timelinesCreateWithoutCrime_incidentsInput[] | timelinesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutCrime_incidentsInput | timelinesCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: timelinesCreateManyCrime_incidentsInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type witnessesCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput> | witnessesCreateWithoutCrime_incidentsInput[] | witnessesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutCrime_incidentsInput | witnessesCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: witnessesCreateManyCrime_incidentsInputEnvelope
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
  }

  export type evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput> | evidenceCreateWithoutCrime_incidentsInput[] | evidenceUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutCrime_incidentsInput | evidenceCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: evidenceCreateManyCrime_incidentsInputEnvelope
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
  }

  export type timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput> | timelinesCreateWithoutCrime_incidentsInput[] | timelinesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutCrime_incidentsInput | timelinesCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: timelinesCreateManyCrime_incidentsInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput = {
    create?: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput> | witnessesCreateWithoutCrime_incidentsInput[] | witnessesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutCrime_incidentsInput | witnessesCreateOrConnectWithoutCrime_incidentsInput[]
    createMany?: witnessesCreateManyCrime_incidentsInputEnvelope
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
  }

  export type NullableEnumcrime_statusFieldUpdateOperationsInput = {
    set?: $Enums.crime_status | null
  }

  export type crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput = {
    create?: XOR<crime_categoriesCreateWithoutCrime_incidentsInput, crime_categoriesUncheckedCreateWithoutCrime_incidentsInput>
    connectOrCreate?: crime_categoriesCreateOrConnectWithoutCrime_incidentsInput
    upsert?: crime_categoriesUpsertWithoutCrime_incidentsInput
    connect?: crime_categoriesWhereUniqueInput
    update?: XOR<XOR<crime_categoriesUpdateToOneWithWhereWithoutCrime_incidentsInput, crime_categoriesUpdateWithoutCrime_incidentsInput>, crime_categoriesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput = {
    create?: XOR<crimesCreateWithoutCrime_incidentsInput, crimesUncheckedCreateWithoutCrime_incidentsInput>
    connectOrCreate?: crimesCreateOrConnectWithoutCrime_incidentsInput
    upsert?: crimesUpsertWithoutCrime_incidentsInput
    connect?: crimesWhereUniqueInput
    update?: XOR<XOR<crimesUpdateToOneWithWhereWithoutCrime_incidentsInput, crimesUpdateWithoutCrime_incidentsInput>, crimesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput = {
    connect?: locationsWhereUniqueInput
    update?: XOR<XOR<locationsUpdateToOneWithWhereWithoutCrime_incidentsInput, locationsUpdateWithoutCrime_incidentsInput>, locationsUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type evidenceUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput> | evidenceCreateWithoutCrime_incidentsInput[] | evidenceUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutCrime_incidentsInput | evidenceCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: evidenceUpsertWithWhereUniqueWithoutCrime_incidentsInput | evidenceUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: evidenceCreateManyCrime_incidentsInputEnvelope
    set?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    disconnect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    delete?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    update?: evidenceUpdateWithWhereUniqueWithoutCrime_incidentsInput | evidenceUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: evidenceUpdateManyWithWhereWithoutCrime_incidentsInput | evidenceUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
  }

  export type timelinesUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput> | timelinesCreateWithoutCrime_incidentsInput[] | timelinesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutCrime_incidentsInput | timelinesCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutCrime_incidentsInput | timelinesUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: timelinesCreateManyCrime_incidentsInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutCrime_incidentsInput | timelinesUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutCrime_incidentsInput | timelinesUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type witnessesUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput> | witnessesCreateWithoutCrime_incidentsInput[] | witnessesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutCrime_incidentsInput | witnessesCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: witnessesUpsertWithWhereUniqueWithoutCrime_incidentsInput | witnessesUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: witnessesCreateManyCrime_incidentsInputEnvelope
    set?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    disconnect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    delete?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    update?: witnessesUpdateWithWhereUniqueWithoutCrime_incidentsInput | witnessesUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: witnessesUpdateManyWithWhereWithoutCrime_incidentsInput | witnessesUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
  }

  export type evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput> | evidenceCreateWithoutCrime_incidentsInput[] | evidenceUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutCrime_incidentsInput | evidenceCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: evidenceUpsertWithWhereUniqueWithoutCrime_incidentsInput | evidenceUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: evidenceCreateManyCrime_incidentsInputEnvelope
    set?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    disconnect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    delete?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    update?: evidenceUpdateWithWhereUniqueWithoutCrime_incidentsInput | evidenceUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: evidenceUpdateManyWithWhereWithoutCrime_incidentsInput | evidenceUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
  }

  export type timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput> | timelinesCreateWithoutCrime_incidentsInput[] | timelinesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutCrime_incidentsInput | timelinesCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutCrime_incidentsInput | timelinesUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: timelinesCreateManyCrime_incidentsInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutCrime_incidentsInput | timelinesUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutCrime_incidentsInput | timelinesUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput = {
    create?: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput> | witnessesCreateWithoutCrime_incidentsInput[] | witnessesUncheckedCreateWithoutCrime_incidentsInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutCrime_incidentsInput | witnessesCreateOrConnectWithoutCrime_incidentsInput[]
    upsert?: witnessesUpsertWithWhereUniqueWithoutCrime_incidentsInput | witnessesUpsertWithWhereUniqueWithoutCrime_incidentsInput[]
    createMany?: witnessesCreateManyCrime_incidentsInputEnvelope
    set?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    disconnect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    delete?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    update?: witnessesUpdateWithWhereUniqueWithoutCrime_incidentsInput | witnessesUpdateWithWhereUniqueWithoutCrime_incidentsInput[]
    updateMany?: witnessesUpdateManyWithWhereWithoutCrime_incidentsInput | witnessesUpdateManyWithWhereWithoutCrime_incidentsInput[]
    deleteMany?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
  }

  export type crime_incidentsCreateNestedManyWithoutCrime_categoriesInput = {
    create?: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput> | crime_incidentsCreateWithoutCrime_categoriesInput[] | crime_incidentsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrime_categoriesInput | crime_incidentsCreateOrConnectWithoutCrime_categoriesInput[]
    createMany?: crime_incidentsCreateManyCrime_categoriesInputEnvelope
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
  }

  export type incident_logsCreateNestedManyWithoutCrime_categoriesInput = {
    create?: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput> | incident_logsCreateWithoutCrime_categoriesInput[] | incident_logsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutCrime_categoriesInput | incident_logsCreateOrConnectWithoutCrime_categoriesInput[]
    createMany?: incident_logsCreateManyCrime_categoriesInputEnvelope
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
  }

  export type crime_incidentsUncheckedCreateNestedManyWithoutCrime_categoriesInput = {
    create?: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput> | crime_incidentsCreateWithoutCrime_categoriesInput[] | crime_incidentsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrime_categoriesInput | crime_incidentsCreateOrConnectWithoutCrime_categoriesInput[]
    createMany?: crime_incidentsCreateManyCrime_categoriesInputEnvelope
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
  }

  export type incident_logsUncheckedCreateNestedManyWithoutCrime_categoriesInput = {
    create?: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput> | incident_logsCreateWithoutCrime_categoriesInput[] | incident_logsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutCrime_categoriesInput | incident_logsCreateOrConnectWithoutCrime_categoriesInput[]
    createMany?: incident_logsCreateManyCrime_categoriesInputEnvelope
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
  }

  export type crime_incidentsUpdateManyWithoutCrime_categoriesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput> | crime_incidentsCreateWithoutCrime_categoriesInput[] | crime_incidentsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrime_categoriesInput | crime_incidentsCreateOrConnectWithoutCrime_categoriesInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutCrime_categoriesInput | crime_incidentsUpsertWithWhereUniqueWithoutCrime_categoriesInput[]
    createMany?: crime_incidentsCreateManyCrime_categoriesInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutCrime_categoriesInput | crime_incidentsUpdateWithWhereUniqueWithoutCrime_categoriesInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutCrime_categoriesInput | crime_incidentsUpdateManyWithWhereWithoutCrime_categoriesInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type incident_logsUpdateManyWithoutCrime_categoriesNestedInput = {
    create?: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput> | incident_logsCreateWithoutCrime_categoriesInput[] | incident_logsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutCrime_categoriesInput | incident_logsCreateOrConnectWithoutCrime_categoriesInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutCrime_categoriesInput | incident_logsUpsertWithWhereUniqueWithoutCrime_categoriesInput[]
    createMany?: incident_logsCreateManyCrime_categoriesInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutCrime_categoriesInput | incident_logsUpdateWithWhereUniqueWithoutCrime_categoriesInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutCrime_categoriesInput | incident_logsUpdateManyWithWhereWithoutCrime_categoriesInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type crime_incidentsUncheckedUpdateManyWithoutCrime_categoriesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput> | crime_incidentsCreateWithoutCrime_categoriesInput[] | crime_incidentsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrime_categoriesInput | crime_incidentsCreateOrConnectWithoutCrime_categoriesInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutCrime_categoriesInput | crime_incidentsUpsertWithWhereUniqueWithoutCrime_categoriesInput[]
    createMany?: crime_incidentsCreateManyCrime_categoriesInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutCrime_categoriesInput | crime_incidentsUpdateWithWhereUniqueWithoutCrime_categoriesInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutCrime_categoriesInput | crime_incidentsUpdateManyWithWhereWithoutCrime_categoriesInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type incident_logsUncheckedUpdateManyWithoutCrime_categoriesNestedInput = {
    create?: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput> | incident_logsCreateWithoutCrime_categoriesInput[] | incident_logsUncheckedCreateWithoutCrime_categoriesInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutCrime_categoriesInput | incident_logsCreateOrConnectWithoutCrime_categoriesInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutCrime_categoriesInput | incident_logsUpsertWithWhereUniqueWithoutCrime_categoriesInput[]
    createMany?: incident_logsCreateManyCrime_categoriesInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutCrime_categoriesInput | incident_logsUpdateWithWhereUniqueWithoutCrime_categoriesInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutCrime_categoriesInput | incident_logsUpdateManyWithWhereWithoutCrime_categoriesInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type crime_incidentsCreateNestedManyWithoutCrimesInput = {
    create?: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput> | crime_incidentsCreateWithoutCrimesInput[] | crime_incidentsUncheckedCreateWithoutCrimesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrimesInput | crime_incidentsCreateOrConnectWithoutCrimesInput[]
    createMany?: crime_incidentsCreateManyCrimesInputEnvelope
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
  }

  export type districtsCreateNestedOneWithoutCrimesInput = {
    create?: XOR<districtsCreateWithoutCrimesInput, districtsUncheckedCreateWithoutCrimesInput>
    connectOrCreate?: districtsCreateOrConnectWithoutCrimesInput
    connect?: districtsWhereUniqueInput
  }

  export type crime_incidentsUncheckedCreateNestedManyWithoutCrimesInput = {
    create?: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput> | crime_incidentsCreateWithoutCrimesInput[] | crime_incidentsUncheckedCreateWithoutCrimesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrimesInput | crime_incidentsCreateOrConnectWithoutCrimesInput[]
    createMany?: crime_incidentsCreateManyCrimesInputEnvelope
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
  }

  export type Enumcrime_ratesFieldUpdateOperationsInput = {
    set?: $Enums.crime_rates
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type crime_incidentsUpdateManyWithoutCrimesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput> | crime_incidentsCreateWithoutCrimesInput[] | crime_incidentsUncheckedCreateWithoutCrimesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrimesInput | crime_incidentsCreateOrConnectWithoutCrimesInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutCrimesInput | crime_incidentsUpsertWithWhereUniqueWithoutCrimesInput[]
    createMany?: crime_incidentsCreateManyCrimesInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutCrimesInput | crime_incidentsUpdateWithWhereUniqueWithoutCrimesInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutCrimesInput | crime_incidentsUpdateManyWithWhereWithoutCrimesInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type districtsUpdateOneRequiredWithoutCrimesNestedInput = {
    create?: XOR<districtsCreateWithoutCrimesInput, districtsUncheckedCreateWithoutCrimesInput>
    connectOrCreate?: districtsCreateOrConnectWithoutCrimesInput
    upsert?: districtsUpsertWithoutCrimesInput
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutCrimesInput, districtsUpdateWithoutCrimesInput>, districtsUncheckedUpdateWithoutCrimesInput>
  }

  export type crime_incidentsUncheckedUpdateManyWithoutCrimesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput> | crime_incidentsCreateWithoutCrimesInput[] | crime_incidentsUncheckedCreateWithoutCrimesInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutCrimesInput | crime_incidentsCreateOrConnectWithoutCrimesInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutCrimesInput | crime_incidentsUpsertWithWhereUniqueWithoutCrimesInput[]
    createMany?: crime_incidentsCreateManyCrimesInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutCrimesInput | crime_incidentsUpdateWithWhereUniqueWithoutCrimesInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutCrimesInput | crime_incidentsUpdateManyWithWhereWithoutCrimesInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type districtsCreateNestedOneWithoutDemographicsInput = {
    create?: XOR<districtsCreateWithoutDemographicsInput, districtsUncheckedCreateWithoutDemographicsInput>
    connectOrCreate?: districtsCreateOrConnectWithoutDemographicsInput
    connect?: districtsWhereUniqueInput
  }

  export type districtsUpdateOneRequiredWithoutDemographicsNestedInput = {
    create?: XOR<districtsCreateWithoutDemographicsInput, districtsUncheckedCreateWithoutDemographicsInput>
    connectOrCreate?: districtsCreateOrConnectWithoutDemographicsInput
    upsert?: districtsUpsertWithoutDemographicsInput
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutDemographicsInput, districtsUpdateWithoutDemographicsInput>, districtsUncheckedUpdateWithoutDemographicsInput>
  }

  export type crimesCreateNestedManyWithoutDistrictsInput = {
    create?: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput> | crimesCreateWithoutDistrictsInput[] | crimesUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: crimesCreateOrConnectWithoutDistrictsInput | crimesCreateOrConnectWithoutDistrictsInput[]
    createMany?: crimesCreateManyDistrictsInputEnvelope
    connect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
  }

  export type demographicsCreateNestedManyWithoutDistrictsInput = {
    create?: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput> | demographicsCreateWithoutDistrictsInput[] | demographicsUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: demographicsCreateOrConnectWithoutDistrictsInput | demographicsCreateOrConnectWithoutDistrictsInput[]
    createMany?: demographicsCreateManyDistrictsInputEnvelope
    connect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
  }

  export type district_clustersCreateNestedManyWithoutDistrictInput = {
    create?: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput> | district_clustersCreateWithoutDistrictInput[] | district_clustersUncheckedCreateWithoutDistrictInput[]
    connectOrCreate?: district_clustersCreateOrConnectWithoutDistrictInput | district_clustersCreateOrConnectWithoutDistrictInput[]
    createMany?: district_clustersCreateManyDistrictInputEnvelope
    connect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
  }

  export type citiesCreateNestedOneWithoutDistrictsInput = {
    create?: XOR<citiesCreateWithoutDistrictsInput, citiesUncheckedCreateWithoutDistrictsInput>
    connectOrCreate?: citiesCreateOrConnectWithoutDistrictsInput
    connect?: citiesWhereUniqueInput
  }

  export type geographicsCreateNestedManyWithoutDistrictsInput = {
    connect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
  }

  export type locationsCreateNestedManyWithoutDistrictsInput = {
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
  }

  export type unitsCreateNestedOneWithoutDistrictsInput = {
    connect?: unitsWhereUniqueInput
  }

  export type crimesUncheckedCreateNestedManyWithoutDistrictsInput = {
    create?: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput> | crimesCreateWithoutDistrictsInput[] | crimesUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: crimesCreateOrConnectWithoutDistrictsInput | crimesCreateOrConnectWithoutDistrictsInput[]
    createMany?: crimesCreateManyDistrictsInputEnvelope
    connect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
  }

  export type demographicsUncheckedCreateNestedManyWithoutDistrictsInput = {
    create?: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput> | demographicsCreateWithoutDistrictsInput[] | demographicsUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: demographicsCreateOrConnectWithoutDistrictsInput | demographicsCreateOrConnectWithoutDistrictsInput[]
    createMany?: demographicsCreateManyDistrictsInputEnvelope
    connect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
  }

  export type district_clustersUncheckedCreateNestedManyWithoutDistrictInput = {
    create?: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput> | district_clustersCreateWithoutDistrictInput[] | district_clustersUncheckedCreateWithoutDistrictInput[]
    connectOrCreate?: district_clustersCreateOrConnectWithoutDistrictInput | district_clustersCreateOrConnectWithoutDistrictInput[]
    createMany?: district_clustersCreateManyDistrictInputEnvelope
    connect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
  }

  export type geographicsUncheckedCreateNestedManyWithoutDistrictsInput = {
    connect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
  }

  export type locationsUncheckedCreateNestedManyWithoutDistrictsInput = {
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
  }

  export type unitsUncheckedCreateNestedOneWithoutDistrictsInput = {
    connect?: unitsWhereUniqueInput
  }

  export type crimesUpdateManyWithoutDistrictsNestedInput = {
    create?: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput> | crimesCreateWithoutDistrictsInput[] | crimesUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: crimesCreateOrConnectWithoutDistrictsInput | crimesCreateOrConnectWithoutDistrictsInput[]
    upsert?: crimesUpsertWithWhereUniqueWithoutDistrictsInput | crimesUpsertWithWhereUniqueWithoutDistrictsInput[]
    createMany?: crimesCreateManyDistrictsInputEnvelope
    set?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    disconnect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    delete?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    connect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    update?: crimesUpdateWithWhereUniqueWithoutDistrictsInput | crimesUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: crimesUpdateManyWithWhereWithoutDistrictsInput | crimesUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: crimesScalarWhereInput | crimesScalarWhereInput[]
  }

  export type demographicsUpdateManyWithoutDistrictsNestedInput = {
    create?: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput> | demographicsCreateWithoutDistrictsInput[] | demographicsUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: demographicsCreateOrConnectWithoutDistrictsInput | demographicsCreateOrConnectWithoutDistrictsInput[]
    upsert?: demographicsUpsertWithWhereUniqueWithoutDistrictsInput | demographicsUpsertWithWhereUniqueWithoutDistrictsInput[]
    createMany?: demographicsCreateManyDistrictsInputEnvelope
    set?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    disconnect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    delete?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    connect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    update?: demographicsUpdateWithWhereUniqueWithoutDistrictsInput | demographicsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: demographicsUpdateManyWithWhereWithoutDistrictsInput | demographicsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: demographicsScalarWhereInput | demographicsScalarWhereInput[]
  }

  export type district_clustersUpdateManyWithoutDistrictNestedInput = {
    create?: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput> | district_clustersCreateWithoutDistrictInput[] | district_clustersUncheckedCreateWithoutDistrictInput[]
    connectOrCreate?: district_clustersCreateOrConnectWithoutDistrictInput | district_clustersCreateOrConnectWithoutDistrictInput[]
    upsert?: district_clustersUpsertWithWhereUniqueWithoutDistrictInput | district_clustersUpsertWithWhereUniqueWithoutDistrictInput[]
    createMany?: district_clustersCreateManyDistrictInputEnvelope
    set?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    disconnect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    delete?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    connect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    update?: district_clustersUpdateWithWhereUniqueWithoutDistrictInput | district_clustersUpdateWithWhereUniqueWithoutDistrictInput[]
    updateMany?: district_clustersUpdateManyWithWhereWithoutDistrictInput | district_clustersUpdateManyWithWhereWithoutDistrictInput[]
    deleteMany?: district_clustersScalarWhereInput | district_clustersScalarWhereInput[]
  }

  export type citiesUpdateOneRequiredWithoutDistrictsNestedInput = {
    create?: XOR<citiesCreateWithoutDistrictsInput, citiesUncheckedCreateWithoutDistrictsInput>
    connectOrCreate?: citiesCreateOrConnectWithoutDistrictsInput
    upsert?: citiesUpsertWithoutDistrictsInput
    connect?: citiesWhereUniqueInput
    update?: XOR<XOR<citiesUpdateToOneWithWhereWithoutDistrictsInput, citiesUpdateWithoutDistrictsInput>, citiesUncheckedUpdateWithoutDistrictsInput>
  }

  export type geographicsUpdateManyWithoutDistrictsNestedInput = {
    set?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    disconnect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    delete?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    connect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    update?: geographicsUpdateWithWhereUniqueWithoutDistrictsInput | geographicsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: geographicsUpdateManyWithWhereWithoutDistrictsInput | geographicsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: geographicsScalarWhereInput | geographicsScalarWhereInput[]
  }

  export type locationsUpdateManyWithoutDistrictsNestedInput = {
    set?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    disconnect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    delete?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    update?: locationsUpdateWithWhereUniqueWithoutDistrictsInput | locationsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: locationsUpdateManyWithWhereWithoutDistrictsInput | locationsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: locationsScalarWhereInput | locationsScalarWhereInput[]
  }

  export type unitsUpdateOneWithoutDistrictsNestedInput = {
    disconnect?: unitsWhereInput | boolean
    delete?: unitsWhereInput | boolean
    connect?: unitsWhereUniqueInput
    update?: XOR<XOR<unitsUpdateToOneWithWhereWithoutDistrictsInput, unitsUpdateWithoutDistrictsInput>, unitsUncheckedUpdateWithoutDistrictsInput>
  }

  export type crimesUncheckedUpdateManyWithoutDistrictsNestedInput = {
    create?: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput> | crimesCreateWithoutDistrictsInput[] | crimesUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: crimesCreateOrConnectWithoutDistrictsInput | crimesCreateOrConnectWithoutDistrictsInput[]
    upsert?: crimesUpsertWithWhereUniqueWithoutDistrictsInput | crimesUpsertWithWhereUniqueWithoutDistrictsInput[]
    createMany?: crimesCreateManyDistrictsInputEnvelope
    set?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    disconnect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    delete?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    connect?: crimesWhereUniqueInput | crimesWhereUniqueInput[]
    update?: crimesUpdateWithWhereUniqueWithoutDistrictsInput | crimesUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: crimesUpdateManyWithWhereWithoutDistrictsInput | crimesUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: crimesScalarWhereInput | crimesScalarWhereInput[]
  }

  export type demographicsUncheckedUpdateManyWithoutDistrictsNestedInput = {
    create?: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput> | demographicsCreateWithoutDistrictsInput[] | demographicsUncheckedCreateWithoutDistrictsInput[]
    connectOrCreate?: demographicsCreateOrConnectWithoutDistrictsInput | demographicsCreateOrConnectWithoutDistrictsInput[]
    upsert?: demographicsUpsertWithWhereUniqueWithoutDistrictsInput | demographicsUpsertWithWhereUniqueWithoutDistrictsInput[]
    createMany?: demographicsCreateManyDistrictsInputEnvelope
    set?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    disconnect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    delete?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    connect?: demographicsWhereUniqueInput | demographicsWhereUniqueInput[]
    update?: demographicsUpdateWithWhereUniqueWithoutDistrictsInput | demographicsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: demographicsUpdateManyWithWhereWithoutDistrictsInput | demographicsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: demographicsScalarWhereInput | demographicsScalarWhereInput[]
  }

  export type district_clustersUncheckedUpdateManyWithoutDistrictNestedInput = {
    create?: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput> | district_clustersCreateWithoutDistrictInput[] | district_clustersUncheckedCreateWithoutDistrictInput[]
    connectOrCreate?: district_clustersCreateOrConnectWithoutDistrictInput | district_clustersCreateOrConnectWithoutDistrictInput[]
    upsert?: district_clustersUpsertWithWhereUniqueWithoutDistrictInput | district_clustersUpsertWithWhereUniqueWithoutDistrictInput[]
    createMany?: district_clustersCreateManyDistrictInputEnvelope
    set?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    disconnect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    delete?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    connect?: district_clustersWhereUniqueInput | district_clustersWhereUniqueInput[]
    update?: district_clustersUpdateWithWhereUniqueWithoutDistrictInput | district_clustersUpdateWithWhereUniqueWithoutDistrictInput[]
    updateMany?: district_clustersUpdateManyWithWhereWithoutDistrictInput | district_clustersUpdateManyWithWhereWithoutDistrictInput[]
    deleteMany?: district_clustersScalarWhereInput | district_clustersScalarWhereInput[]
  }

  export type geographicsUncheckedUpdateManyWithoutDistrictsNestedInput = {
    set?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    disconnect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    delete?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    connect?: geographicsWhereUniqueInput | geographicsWhereUniqueInput[]
    update?: geographicsUpdateWithWhereUniqueWithoutDistrictsInput | geographicsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: geographicsUpdateManyWithWhereWithoutDistrictsInput | geographicsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: geographicsScalarWhereInput | geographicsScalarWhereInput[]
  }

  export type locationsUncheckedUpdateManyWithoutDistrictsNestedInput = {
    set?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    disconnect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    delete?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    connect?: locationsWhereUniqueInput | locationsWhereUniqueInput[]
    update?: locationsUpdateWithWhereUniqueWithoutDistrictsInput | locationsUpdateWithWhereUniqueWithoutDistrictsInput[]
    updateMany?: locationsUpdateManyWithWhereWithoutDistrictsInput | locationsUpdateManyWithWhereWithoutDistrictsInput[]
    deleteMany?: locationsScalarWhereInput | locationsScalarWhereInput[]
  }

  export type unitsUncheckedUpdateOneWithoutDistrictsNestedInput = {
    disconnect?: unitsWhereInput | boolean
    delete?: unitsWhereInput | boolean
    connect?: unitsWhereUniqueInput
    update?: XOR<XOR<unitsUpdateToOneWithWhereWithoutDistrictsInput, unitsUpdateWithoutDistrictsInput>, unitsUncheckedUpdateWithoutDistrictsInput>
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type crime_incidentsUpdateManyWithoutLocationsNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutLocationsInput, crime_incidentsUncheckedCreateWithoutLocationsInput> | crime_incidentsCreateWithoutLocationsInput[] | crime_incidentsUncheckedCreateWithoutLocationsInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutLocationsInput | crime_incidentsCreateOrConnectWithoutLocationsInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutLocationsInput | crime_incidentsUpsertWithWhereUniqueWithoutLocationsInput[]
    createMany?: crime_incidentsCreateManyLocationsInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutLocationsInput | crime_incidentsUpdateWithWhereUniqueWithoutLocationsInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutLocationsInput | crime_incidentsUpdateManyWithWhereWithoutLocationsInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type incident_logsUpdateManyWithoutLocationsNestedInput = {
    create?: XOR<incident_logsCreateWithoutLocationsInput, incident_logsUncheckedCreateWithoutLocationsInput> | incident_logsCreateWithoutLocationsInput[] | incident_logsUncheckedCreateWithoutLocationsInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutLocationsInput | incident_logsCreateOrConnectWithoutLocationsInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutLocationsInput | incident_logsUpsertWithWhereUniqueWithoutLocationsInput[]
    createMany?: incident_logsCreateManyLocationsInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutLocationsInput | incident_logsUpdateWithWhereUniqueWithoutLocationsInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutLocationsInput | incident_logsUpdateManyWithWhereWithoutLocationsInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type location_logsUpdateManyWithoutLocationNestedInput = {
    set?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    disconnect?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    delete?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    connect?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    update?: location_logsUpdateWithWhereUniqueWithoutLocationInput | location_logsUpdateWithWhereUniqueWithoutLocationInput[]
    updateMany?: location_logsUpdateManyWithWhereWithoutLocationInput | location_logsUpdateManyWithWhereWithoutLocationInput[]
    deleteMany?: location_logsScalarWhereInput | location_logsScalarWhereInput[]
  }

  export type districtsUpdateOneRequiredWithoutLocationsNestedInput = {
    create?: XOR<districtsCreateWithoutLocationsInput, districtsUncheckedCreateWithoutLocationsInput>
    connectOrCreate?: districtsCreateOrConnectWithoutLocationsInput
    upsert?: districtsUpsertWithoutLocationsInput
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutLocationsInput, districtsUpdateWithoutLocationsInput>, districtsUncheckedUpdateWithoutLocationsInput>
  }

  export type eventsUpdateOneRequiredWithoutLocationsNestedInput = {
    create?: XOR<eventsCreateWithoutLocationsInput, eventsUncheckedCreateWithoutLocationsInput>
    connectOrCreate?: eventsCreateOrConnectWithoutLocationsInput
    upsert?: eventsUpsertWithoutLocationsInput
    connect?: eventsWhereUniqueInput
    update?: XOR<XOR<eventsUpdateToOneWithWhereWithoutLocationsInput, eventsUpdateWithoutLocationsInput>, eventsUncheckedUpdateWithoutLocationsInput>
  }

  export type patrol_unitsUpdateManyWithoutLocationNestedInput = {
    create?: XOR<patrol_unitsCreateWithoutLocationInput, patrol_unitsUncheckedCreateWithoutLocationInput> | patrol_unitsCreateWithoutLocationInput[] | patrol_unitsUncheckedCreateWithoutLocationInput[]
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutLocationInput | patrol_unitsCreateOrConnectWithoutLocationInput[]
    upsert?: patrol_unitsUpsertWithWhereUniqueWithoutLocationInput | patrol_unitsUpsertWithWhereUniqueWithoutLocationInput[]
    createMany?: patrol_unitsCreateManyLocationInputEnvelope
    set?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    disconnect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    delete?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    connect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    update?: patrol_unitsUpdateWithWhereUniqueWithoutLocationInput | patrol_unitsUpdateWithWhereUniqueWithoutLocationInput[]
    updateMany?: patrol_unitsUpdateManyWithWhereWithoutLocationInput | patrol_unitsUpdateManyWithWhereWithoutLocationInput[]
    deleteMany?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
  }

  export type crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutLocationsInput, crime_incidentsUncheckedCreateWithoutLocationsInput> | crime_incidentsCreateWithoutLocationsInput[] | crime_incidentsUncheckedCreateWithoutLocationsInput[]
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutLocationsInput | crime_incidentsCreateOrConnectWithoutLocationsInput[]
    upsert?: crime_incidentsUpsertWithWhereUniqueWithoutLocationsInput | crime_incidentsUpsertWithWhereUniqueWithoutLocationsInput[]
    createMany?: crime_incidentsCreateManyLocationsInputEnvelope
    set?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    disconnect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    delete?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    connect?: crime_incidentsWhereUniqueInput | crime_incidentsWhereUniqueInput[]
    update?: crime_incidentsUpdateWithWhereUniqueWithoutLocationsInput | crime_incidentsUpdateWithWhereUniqueWithoutLocationsInput[]
    updateMany?: crime_incidentsUpdateManyWithWhereWithoutLocationsInput | crime_incidentsUpdateManyWithWhereWithoutLocationsInput[]
    deleteMany?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
  }

  export type incident_logsUncheckedUpdateManyWithoutLocationsNestedInput = {
    create?: XOR<incident_logsCreateWithoutLocationsInput, incident_logsUncheckedCreateWithoutLocationsInput> | incident_logsCreateWithoutLocationsInput[] | incident_logsUncheckedCreateWithoutLocationsInput[]
    connectOrCreate?: incident_logsCreateOrConnectWithoutLocationsInput | incident_logsCreateOrConnectWithoutLocationsInput[]
    upsert?: incident_logsUpsertWithWhereUniqueWithoutLocationsInput | incident_logsUpsertWithWhereUniqueWithoutLocationsInput[]
    createMany?: incident_logsCreateManyLocationsInputEnvelope
    set?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    disconnect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    delete?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    connect?: incident_logsWhereUniqueInput | incident_logsWhereUniqueInput[]
    update?: incident_logsUpdateWithWhereUniqueWithoutLocationsInput | incident_logsUpdateWithWhereUniqueWithoutLocationsInput[]
    updateMany?: incident_logsUpdateManyWithWhereWithoutLocationsInput | incident_logsUpdateManyWithWhereWithoutLocationsInput[]
    deleteMany?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
  }

  export type location_logsUncheckedUpdateManyWithoutLocationNestedInput = {
    set?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    disconnect?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    delete?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    connect?: location_logsWhereUniqueInput | location_logsWhereUniqueInput[]
    update?: location_logsUpdateWithWhereUniqueWithoutLocationInput | location_logsUpdateWithWhereUniqueWithoutLocationInput[]
    updateMany?: location_logsUpdateManyWithWhereWithoutLocationInput | location_logsUpdateManyWithWhereWithoutLocationInput[]
    deleteMany?: location_logsScalarWhereInput | location_logsScalarWhereInput[]
  }

  export type patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput = {
    create?: XOR<patrol_unitsCreateWithoutLocationInput, patrol_unitsUncheckedCreateWithoutLocationInput> | patrol_unitsCreateWithoutLocationInput[] | patrol_unitsUncheckedCreateWithoutLocationInput[]
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutLocationInput | patrol_unitsCreateOrConnectWithoutLocationInput[]
    upsert?: patrol_unitsUpsertWithWhereUniqueWithoutLocationInput | patrol_unitsUpsertWithWhereUniqueWithoutLocationInput[]
    createMany?: patrol_unitsCreateManyLocationInputEnvelope
    set?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    disconnect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    delete?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    connect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    update?: patrol_unitsUpdateWithWhereUniqueWithoutLocationInput | patrol_unitsUpdateWithWhereUniqueWithoutLocationInput[]
    updateMany?: patrol_unitsUpdateManyWithWhereWithoutLocationInput | patrol_unitsUpdateManyWithWhereWithoutLocationInput[]
    deleteMany?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
  }

  export type evidenceCreateNestedManyWithoutIncidentInput = {
    create?: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput> | evidenceCreateWithoutIncidentInput[] | evidenceUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutIncidentInput | evidenceCreateOrConnectWithoutIncidentInput[]
    createMany?: evidenceCreateManyIncidentInputEnvelope
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
  }

  export type crime_categoriesCreateNestedOneWithoutIncident_logsInput = {
    create?: XOR<crime_categoriesCreateWithoutIncident_logsInput, crime_categoriesUncheckedCreateWithoutIncident_logsInput>
    connectOrCreate?: crime_categoriesCreateOrConnectWithoutIncident_logsInput
    connect?: crime_categoriesWhereUniqueInput
  }

  export type locationsCreateNestedOneWithoutIncident_logsInput = {
    connect?: locationsWhereUniqueInput
  }

  export type usersCreateNestedOneWithoutIncident_logsInput = {
    create?: XOR<usersCreateWithoutIncident_logsInput, usersUncheckedCreateWithoutIncident_logsInput>
    connectOrCreate?: usersCreateOrConnectWithoutIncident_logsInput
    connect?: usersWhereUniqueInput
  }

  export type panic_button_logsCreateNestedManyWithoutIncidentsInput = {
    create?: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput> | panic_button_logsCreateWithoutIncidentsInput[] | panic_button_logsUncheckedCreateWithoutIncidentsInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutIncidentsInput | panic_button_logsCreateOrConnectWithoutIncidentsInput[]
    createMany?: panic_button_logsCreateManyIncidentsInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type timelinesCreateNestedManyWithoutIncidentInput = {
    create?: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput> | timelinesCreateWithoutIncidentInput[] | timelinesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutIncidentInput | timelinesCreateOrConnectWithoutIncidentInput[]
    createMany?: timelinesCreateManyIncidentInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type witnessesCreateNestedManyWithoutIncidentInput = {
    create?: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput> | witnessesCreateWithoutIncidentInput[] | witnessesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutIncidentInput | witnessesCreateOrConnectWithoutIncidentInput[]
    createMany?: witnessesCreateManyIncidentInputEnvelope
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
  }

  export type evidenceUncheckedCreateNestedManyWithoutIncidentInput = {
    create?: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput> | evidenceCreateWithoutIncidentInput[] | evidenceUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutIncidentInput | evidenceCreateOrConnectWithoutIncidentInput[]
    createMany?: evidenceCreateManyIncidentInputEnvelope
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
  }

  export type panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput = {
    create?: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput> | panic_button_logsCreateWithoutIncidentsInput[] | panic_button_logsUncheckedCreateWithoutIncidentsInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutIncidentsInput | panic_button_logsCreateOrConnectWithoutIncidentsInput[]
    createMany?: panic_button_logsCreateManyIncidentsInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type timelinesUncheckedCreateNestedManyWithoutIncidentInput = {
    create?: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput> | timelinesCreateWithoutIncidentInput[] | timelinesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutIncidentInput | timelinesCreateOrConnectWithoutIncidentInput[]
    createMany?: timelinesCreateManyIncidentInputEnvelope
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
  }

  export type witnessesUncheckedCreateNestedManyWithoutIncidentInput = {
    create?: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput> | witnessesCreateWithoutIncidentInput[] | witnessesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutIncidentInput | witnessesCreateOrConnectWithoutIncidentInput[]
    createMany?: witnessesCreateManyIncidentInputEnvelope
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

  export type evidenceUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput> | evidenceCreateWithoutIncidentInput[] | evidenceUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutIncidentInput | evidenceCreateOrConnectWithoutIncidentInput[]
    upsert?: evidenceUpsertWithWhereUniqueWithoutIncidentInput | evidenceUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: evidenceCreateManyIncidentInputEnvelope
    set?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    disconnect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    delete?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    update?: evidenceUpdateWithWhereUniqueWithoutIncidentInput | evidenceUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: evidenceUpdateManyWithWhereWithoutIncidentInput | evidenceUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
  }

  export type crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput = {
    create?: XOR<crime_categoriesCreateWithoutIncident_logsInput, crime_categoriesUncheckedCreateWithoutIncident_logsInput>
    connectOrCreate?: crime_categoriesCreateOrConnectWithoutIncident_logsInput
    upsert?: crime_categoriesUpsertWithoutIncident_logsInput
    connect?: crime_categoriesWhereUniqueInput
    update?: XOR<XOR<crime_categoriesUpdateToOneWithWhereWithoutIncident_logsInput, crime_categoriesUpdateWithoutIncident_logsInput>, crime_categoriesUncheckedUpdateWithoutIncident_logsInput>
  }

  export type locationsUpdateOneRequiredWithoutIncident_logsNestedInput = {
    connect?: locationsWhereUniqueInput
    update?: XOR<XOR<locationsUpdateToOneWithWhereWithoutIncident_logsInput, locationsUpdateWithoutIncident_logsInput>, locationsUncheckedUpdateWithoutIncident_logsInput>
  }

  export type usersUpdateOneRequiredWithoutIncident_logsNestedInput = {
    create?: XOR<usersCreateWithoutIncident_logsInput, usersUncheckedCreateWithoutIncident_logsInput>
    connectOrCreate?: usersCreateOrConnectWithoutIncident_logsInput
    upsert?: usersUpsertWithoutIncident_logsInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutIncident_logsInput, usersUpdateWithoutIncident_logsInput>, usersUncheckedUpdateWithoutIncident_logsInput>
  }

  export type panic_button_logsUpdateManyWithoutIncidentsNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput> | panic_button_logsCreateWithoutIncidentsInput[] | panic_button_logsUncheckedCreateWithoutIncidentsInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutIncidentsInput | panic_button_logsCreateOrConnectWithoutIncidentsInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutIncidentsInput | panic_button_logsUpsertWithWhereUniqueWithoutIncidentsInput[]
    createMany?: panic_button_logsCreateManyIncidentsInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutIncidentsInput | panic_button_logsUpdateWithWhereUniqueWithoutIncidentsInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutIncidentsInput | panic_button_logsUpdateManyWithWhereWithoutIncidentsInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type timelinesUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput> | timelinesCreateWithoutIncidentInput[] | timelinesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutIncidentInput | timelinesCreateOrConnectWithoutIncidentInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutIncidentInput | timelinesUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: timelinesCreateManyIncidentInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutIncidentInput | timelinesUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutIncidentInput | timelinesUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type witnessesUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput> | witnessesCreateWithoutIncidentInput[] | witnessesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutIncidentInput | witnessesCreateOrConnectWithoutIncidentInput[]
    upsert?: witnessesUpsertWithWhereUniqueWithoutIncidentInput | witnessesUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: witnessesCreateManyIncidentInputEnvelope
    set?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    disconnect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    delete?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    update?: witnessesUpdateWithWhereUniqueWithoutIncidentInput | witnessesUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: witnessesUpdateManyWithWhereWithoutIncidentInput | witnessesUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
  }

  export type evidenceUncheckedUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput> | evidenceCreateWithoutIncidentInput[] | evidenceUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: evidenceCreateOrConnectWithoutIncidentInput | evidenceCreateOrConnectWithoutIncidentInput[]
    upsert?: evidenceUpsertWithWhereUniqueWithoutIncidentInput | evidenceUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: evidenceCreateManyIncidentInputEnvelope
    set?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    disconnect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    delete?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    connect?: evidenceWhereUniqueInput | evidenceWhereUniqueInput[]
    update?: evidenceUpdateWithWhereUniqueWithoutIncidentInput | evidenceUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: evidenceUpdateManyWithWhereWithoutIncidentInput | evidenceUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
  }

  export type panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput> | panic_button_logsCreateWithoutIncidentsInput[] | panic_button_logsUncheckedCreateWithoutIncidentsInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutIncidentsInput | panic_button_logsCreateOrConnectWithoutIncidentsInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutIncidentsInput | panic_button_logsUpsertWithWhereUniqueWithoutIncidentsInput[]
    createMany?: panic_button_logsCreateManyIncidentsInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutIncidentsInput | panic_button_logsUpdateWithWhereUniqueWithoutIncidentsInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutIncidentsInput | panic_button_logsUpdateManyWithWhereWithoutIncidentsInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type timelinesUncheckedUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput> | timelinesCreateWithoutIncidentInput[] | timelinesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: timelinesCreateOrConnectWithoutIncidentInput | timelinesCreateOrConnectWithoutIncidentInput[]
    upsert?: timelinesUpsertWithWhereUniqueWithoutIncidentInput | timelinesUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: timelinesCreateManyIncidentInputEnvelope
    set?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    disconnect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    delete?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    connect?: timelinesWhereUniqueInput | timelinesWhereUniqueInput[]
    update?: timelinesUpdateWithWhereUniqueWithoutIncidentInput | timelinesUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: timelinesUpdateManyWithWhereWithoutIncidentInput | timelinesUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
  }

  export type witnessesUncheckedUpdateManyWithoutIncidentNestedInput = {
    create?: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput> | witnessesCreateWithoutIncidentInput[] | witnessesUncheckedCreateWithoutIncidentInput[]
    connectOrCreate?: witnessesCreateOrConnectWithoutIncidentInput | witnessesCreateOrConnectWithoutIncidentInput[]
    upsert?: witnessesUpsertWithWhereUniqueWithoutIncidentInput | witnessesUpsertWithWhereUniqueWithoutIncidentInput[]
    createMany?: witnessesCreateManyIncidentInputEnvelope
    set?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    disconnect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    delete?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    connect?: witnessesWhereUniqueInput | witnessesWhereUniqueInput[]
    update?: witnessesUpdateWithWhereUniqueWithoutIncidentInput | witnessesUpdateWithWhereUniqueWithoutIncidentInput[]
    updateMany?: witnessesUpdateManyWithWhereWithoutIncidentInput | witnessesUpdateManyWithWhereWithoutIncidentInput[]
    deleteMany?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
  }

  export type crime_incidentsCreateNestedOneWithoutTimelinesInput = {
    create?: XOR<crime_incidentsCreateWithoutTimelinesInput, crime_incidentsUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutTimelinesInput
    connect?: crime_incidentsWhereUniqueInput
  }

  export type incident_logsCreateNestedOneWithoutTimelinesInput = {
    create?: XOR<incident_logsCreateWithoutTimelinesInput, incident_logsUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutTimelinesInput
    connect?: incident_logsWhereUniqueInput
  }

  export type usersCreateNestedOneWithoutTimelinesInput = {
    create?: XOR<usersCreateWithoutTimelinesInput, usersUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: usersCreateOrConnectWithoutTimelinesInput
    connect?: usersWhereUniqueInput
  }

  export type crime_incidentsUpdateOneWithoutTimelinesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutTimelinesInput, crime_incidentsUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutTimelinesInput
    upsert?: crime_incidentsUpsertWithoutTimelinesInput
    disconnect?: crime_incidentsWhereInput | boolean
    delete?: crime_incidentsWhereInput | boolean
    connect?: crime_incidentsWhereUniqueInput
    update?: XOR<XOR<crime_incidentsUpdateToOneWithWhereWithoutTimelinesInput, crime_incidentsUpdateWithoutTimelinesInput>, crime_incidentsUncheckedUpdateWithoutTimelinesInput>
  }

  export type incident_logsUpdateOneWithoutTimelinesNestedInput = {
    create?: XOR<incident_logsCreateWithoutTimelinesInput, incident_logsUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutTimelinesInput
    upsert?: incident_logsUpsertWithoutTimelinesInput
    disconnect?: incident_logsWhereInput | boolean
    delete?: incident_logsWhereInput | boolean
    connect?: incident_logsWhereUniqueInput
    update?: XOR<XOR<incident_logsUpdateToOneWithWhereWithoutTimelinesInput, incident_logsUpdateWithoutTimelinesInput>, incident_logsUncheckedUpdateWithoutTimelinesInput>
  }

  export type usersUpdateOneWithoutTimelinesNestedInput = {
    create?: XOR<usersCreateWithoutTimelinesInput, usersUncheckedCreateWithoutTimelinesInput>
    connectOrCreate?: usersCreateOrConnectWithoutTimelinesInput
    upsert?: usersUpsertWithoutTimelinesInput
    disconnect?: usersWhereInput | boolean
    delete?: usersWhereInput | boolean
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutTimelinesInput, usersUpdateWithoutTimelinesInput>, usersUncheckedUpdateWithoutTimelinesInput>
  }

  export type crime_incidentsCreateNestedOneWithoutWitnessesInput = {
    create?: XOR<crime_incidentsCreateWithoutWitnessesInput, crime_incidentsUncheckedCreateWithoutWitnessesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutWitnessesInput
    connect?: crime_incidentsWhereUniqueInput
  }

  export type incident_logsCreateNestedOneWithoutWitnessesInput = {
    create?: XOR<incident_logsCreateWithoutWitnessesInput, incident_logsUncheckedCreateWithoutWitnessesInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutWitnessesInput
    connect?: incident_logsWhereUniqueInput
  }

  export type crime_incidentsUpdateOneWithoutWitnessesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutWitnessesInput, crime_incidentsUncheckedCreateWithoutWitnessesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutWitnessesInput
    upsert?: crime_incidentsUpsertWithoutWitnessesInput
    disconnect?: crime_incidentsWhereInput | boolean
    delete?: crime_incidentsWhereInput | boolean
    connect?: crime_incidentsWhereUniqueInput
    update?: XOR<XOR<crime_incidentsUpdateToOneWithWhereWithoutWitnessesInput, crime_incidentsUpdateWithoutWitnessesInput>, crime_incidentsUncheckedUpdateWithoutWitnessesInput>
  }

  export type incident_logsUpdateOneWithoutWitnessesNestedInput = {
    create?: XOR<incident_logsCreateWithoutWitnessesInput, incident_logsUncheckedCreateWithoutWitnessesInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutWitnessesInput
    upsert?: incident_logsUpsertWithoutWitnessesInput
    disconnect?: incident_logsWhereInput | boolean
    delete?: incident_logsWhereInput | boolean
    connect?: incident_logsWhereUniqueInput
    update?: XOR<XOR<incident_logsUpdateToOneWithWhereWithoutWitnessesInput, incident_logsUpdateWithoutWitnessesInput>, incident_logsUncheckedUpdateWithoutWitnessesInput>
  }

  export type crime_incidentsCreateNestedOneWithoutEvidencesInput = {
    create?: XOR<crime_incidentsCreateWithoutEvidencesInput, crime_incidentsUncheckedCreateWithoutEvidencesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutEvidencesInput
    connect?: crime_incidentsWhereUniqueInput
  }

  export type incident_logsCreateNestedOneWithoutEvidenceInput = {
    create?: XOR<incident_logsCreateWithoutEvidenceInput, incident_logsUncheckedCreateWithoutEvidenceInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutEvidenceInput
    connect?: incident_logsWhereUniqueInput
  }

  export type crime_incidentsUpdateOneWithoutEvidencesNestedInput = {
    create?: XOR<crime_incidentsCreateWithoutEvidencesInput, crime_incidentsUncheckedCreateWithoutEvidencesInput>
    connectOrCreate?: crime_incidentsCreateOrConnectWithoutEvidencesInput
    upsert?: crime_incidentsUpsertWithoutEvidencesInput
    disconnect?: crime_incidentsWhereInput | boolean
    delete?: crime_incidentsWhereInput | boolean
    connect?: crime_incidentsWhereUniqueInput
    update?: XOR<XOR<crime_incidentsUpdateToOneWithWhereWithoutEvidencesInput, crime_incidentsUpdateWithoutEvidencesInput>, crime_incidentsUncheckedUpdateWithoutEvidencesInput>
  }

  export type incident_logsUpdateOneWithoutEvidenceNestedInput = {
    create?: XOR<incident_logsCreateWithoutEvidenceInput, incident_logsUncheckedCreateWithoutEvidenceInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutEvidenceInput
    upsert?: incident_logsUpsertWithoutEvidenceInput
    disconnect?: incident_logsWhereInput | boolean
    delete?: incident_logsWhereInput | boolean
    connect?: incident_logsWhereUniqueInput
    update?: XOR<XOR<incident_logsUpdateToOneWithWhereWithoutEvidenceInput, incident_logsUpdateWithoutEvidenceInput>, incident_logsUncheckedUpdateWithoutEvidenceInput>
  }

  export type Enumunit_typeFieldUpdateOperationsInput = {
    set?: $Enums.unit_type
  }

  export type officersUpdateManyWithoutUnitsNestedInput = {
    create?: XOR<officersCreateWithoutUnitsInput, officersUncheckedCreateWithoutUnitsInput> | officersCreateWithoutUnitsInput[] | officersUncheckedCreateWithoutUnitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutUnitsInput | officersCreateOrConnectWithoutUnitsInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutUnitsInput | officersUpsertWithWhereUniqueWithoutUnitsInput[]
    createMany?: officersCreateManyUnitsInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutUnitsInput | officersUpdateWithWhereUniqueWithoutUnitsInput[]
    updateMany?: officersUpdateManyWithWhereWithoutUnitsInput | officersUpdateManyWithWhereWithoutUnitsInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type patrol_unitsUpdateManyWithoutUnitNestedInput = {
    create?: XOR<patrol_unitsCreateWithoutUnitInput, patrol_unitsUncheckedCreateWithoutUnitInput> | patrol_unitsCreateWithoutUnitInput[] | patrol_unitsUncheckedCreateWithoutUnitInput[]
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutUnitInput | patrol_unitsCreateOrConnectWithoutUnitInput[]
    upsert?: patrol_unitsUpsertWithWhereUniqueWithoutUnitInput | patrol_unitsUpsertWithWhereUniqueWithoutUnitInput[]
    createMany?: patrol_unitsCreateManyUnitInputEnvelope
    set?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    disconnect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    delete?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    connect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    update?: patrol_unitsUpdateWithWhereUniqueWithoutUnitInput | patrol_unitsUpdateWithWhereUniqueWithoutUnitInput[]
    updateMany?: patrol_unitsUpdateManyWithWhereWithoutUnitInput | patrol_unitsUpdateManyWithWhereWithoutUnitInput[]
    deleteMany?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
  }

  export type unit_statisticsUpdateManyWithoutUnitsNestedInput = {
    create?: XOR<unit_statisticsCreateWithoutUnitsInput, unit_statisticsUncheckedCreateWithoutUnitsInput> | unit_statisticsCreateWithoutUnitsInput[] | unit_statisticsUncheckedCreateWithoutUnitsInput[]
    connectOrCreate?: unit_statisticsCreateOrConnectWithoutUnitsInput | unit_statisticsCreateOrConnectWithoutUnitsInput[]
    upsert?: unit_statisticsUpsertWithWhereUniqueWithoutUnitsInput | unit_statisticsUpsertWithWhereUniqueWithoutUnitsInput[]
    createMany?: unit_statisticsCreateManyUnitsInputEnvelope
    set?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    disconnect?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    delete?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    connect?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    update?: unit_statisticsUpdateWithWhereUniqueWithoutUnitsInput | unit_statisticsUpdateWithWhereUniqueWithoutUnitsInput[]
    updateMany?: unit_statisticsUpdateManyWithWhereWithoutUnitsInput | unit_statisticsUpdateManyWithWhereWithoutUnitsInput[]
    deleteMany?: unit_statisticsScalarWhereInput | unit_statisticsScalarWhereInput[]
  }

  export type citiesUpdateOneRequiredWithoutUnitsNestedInput = {
    create?: XOR<citiesCreateWithoutUnitsInput, citiesUncheckedCreateWithoutUnitsInput>
    connectOrCreate?: citiesCreateOrConnectWithoutUnitsInput
    upsert?: citiesUpsertWithoutUnitsInput
    connect?: citiesWhereUniqueInput
    update?: XOR<XOR<citiesUpdateToOneWithWhereWithoutUnitsInput, citiesUpdateWithoutUnitsInput>, citiesUncheckedUpdateWithoutUnitsInput>
  }

  export type districtsUpdateOneWithoutUnitsNestedInput = {
    create?: XOR<districtsCreateWithoutUnitsInput, districtsUncheckedCreateWithoutUnitsInput>
    connectOrCreate?: districtsCreateOrConnectWithoutUnitsInput
    upsert?: districtsUpsertWithoutUnitsInput
    disconnect?: districtsWhereInput | boolean
    delete?: districtsWhereInput | boolean
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutUnitsInput, districtsUpdateWithoutUnitsInput>, districtsUncheckedUpdateWithoutUnitsInput>
  }

  export type officersUncheckedUpdateManyWithoutUnitsNestedInput = {
    create?: XOR<officersCreateWithoutUnitsInput, officersUncheckedCreateWithoutUnitsInput> | officersCreateWithoutUnitsInput[] | officersUncheckedCreateWithoutUnitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutUnitsInput | officersCreateOrConnectWithoutUnitsInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutUnitsInput | officersUpsertWithWhereUniqueWithoutUnitsInput[]
    createMany?: officersCreateManyUnitsInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutUnitsInput | officersUpdateWithWhereUniqueWithoutUnitsInput[]
    updateMany?: officersUpdateManyWithWhereWithoutUnitsInput | officersUpdateManyWithWhereWithoutUnitsInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput = {
    create?: XOR<patrol_unitsCreateWithoutUnitInput, patrol_unitsUncheckedCreateWithoutUnitInput> | patrol_unitsCreateWithoutUnitInput[] | patrol_unitsUncheckedCreateWithoutUnitInput[]
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutUnitInput | patrol_unitsCreateOrConnectWithoutUnitInput[]
    upsert?: patrol_unitsUpsertWithWhereUniqueWithoutUnitInput | patrol_unitsUpsertWithWhereUniqueWithoutUnitInput[]
    createMany?: patrol_unitsCreateManyUnitInputEnvelope
    set?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    disconnect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    delete?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    connect?: patrol_unitsWhereUniqueInput | patrol_unitsWhereUniqueInput[]
    update?: patrol_unitsUpdateWithWhereUniqueWithoutUnitInput | patrol_unitsUpdateWithWhereUniqueWithoutUnitInput[]
    updateMany?: patrol_unitsUpdateManyWithWhereWithoutUnitInput | patrol_unitsUpdateManyWithWhereWithoutUnitInput[]
    deleteMany?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
  }

  export type unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput = {
    create?: XOR<unit_statisticsCreateWithoutUnitsInput, unit_statisticsUncheckedCreateWithoutUnitsInput> | unit_statisticsCreateWithoutUnitsInput[] | unit_statisticsUncheckedCreateWithoutUnitsInput[]
    connectOrCreate?: unit_statisticsCreateOrConnectWithoutUnitsInput | unit_statisticsCreateOrConnectWithoutUnitsInput[]
    upsert?: unit_statisticsUpsertWithWhereUniqueWithoutUnitsInput | unit_statisticsUpsertWithWhereUniqueWithoutUnitsInput[]
    createMany?: unit_statisticsCreateManyUnitsInputEnvelope
    set?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    disconnect?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    delete?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    connect?: unit_statisticsWhereUniqueInput | unit_statisticsWhereUniqueInput[]
    update?: unit_statisticsUpdateWithWhereUniqueWithoutUnitsInput | unit_statisticsUpdateWithWhereUniqueWithoutUnitsInput[]
    updateMany?: unit_statisticsUpdateManyWithWhereWithoutUnitsInput | unit_statisticsUpdateManyWithWhereWithoutUnitsInput[]
    deleteMany?: unit_statisticsScalarWhereInput | unit_statisticsScalarWhereInput[]
  }

  export type officersCreateNestedManyWithoutPatrol_unitsInput = {
    create?: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput> | officersCreateWithoutPatrol_unitsInput[] | officersUncheckedCreateWithoutPatrol_unitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutPatrol_unitsInput | officersCreateOrConnectWithoutPatrol_unitsInput[]
    createMany?: officersCreateManyPatrol_unitsInputEnvelope
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
  }

  export type locationsCreateNestedOneWithoutPatrol_unitsInput = {
    connect?: locationsWhereUniqueInput
  }

  export type unitsCreateNestedOneWithoutPatrol_unitsInput = {
    connect?: unitsWhereUniqueInput
  }

  export type officersUncheckedCreateNestedManyWithoutPatrol_unitsInput = {
    create?: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput> | officersCreateWithoutPatrol_unitsInput[] | officersUncheckedCreateWithoutPatrol_unitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutPatrol_unitsInput | officersCreateOrConnectWithoutPatrol_unitsInput[]
    createMany?: officersCreateManyPatrol_unitsInputEnvelope
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
  }

  export type NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput = {
    set?: $Enums.patrol_unit_category | null
  }

  export type officersUpdateManyWithoutPatrol_unitsNestedInput = {
    create?: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput> | officersCreateWithoutPatrol_unitsInput[] | officersUncheckedCreateWithoutPatrol_unitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutPatrol_unitsInput | officersCreateOrConnectWithoutPatrol_unitsInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutPatrol_unitsInput | officersUpsertWithWhereUniqueWithoutPatrol_unitsInput[]
    createMany?: officersCreateManyPatrol_unitsInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutPatrol_unitsInput | officersUpdateWithWhereUniqueWithoutPatrol_unitsInput[]
    updateMany?: officersUpdateManyWithWhereWithoutPatrol_unitsInput | officersUpdateManyWithWhereWithoutPatrol_unitsInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type locationsUpdateOneRequiredWithoutPatrol_unitsNestedInput = {
    connect?: locationsWhereUniqueInput
    update?: XOR<XOR<locationsUpdateToOneWithWhereWithoutPatrol_unitsInput, locationsUpdateWithoutPatrol_unitsInput>, locationsUncheckedUpdateWithoutPatrol_unitsInput>
  }

  export type unitsUpdateOneRequiredWithoutPatrol_unitsNestedInput = {
    connect?: unitsWhereUniqueInput
    update?: XOR<XOR<unitsUpdateToOneWithWhereWithoutPatrol_unitsInput, unitsUpdateWithoutPatrol_unitsInput>, unitsUncheckedUpdateWithoutPatrol_unitsInput>
  }

  export type officersUncheckedUpdateManyWithoutPatrol_unitsNestedInput = {
    create?: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput> | officersCreateWithoutPatrol_unitsInput[] | officersUncheckedCreateWithoutPatrol_unitsInput[]
    connectOrCreate?: officersCreateOrConnectWithoutPatrol_unitsInput | officersCreateOrConnectWithoutPatrol_unitsInput[]
    upsert?: officersUpsertWithWhereUniqueWithoutPatrol_unitsInput | officersUpsertWithWhereUniqueWithoutPatrol_unitsInput[]
    createMany?: officersCreateManyPatrol_unitsInputEnvelope
    set?: officersWhereUniqueInput | officersWhereUniqueInput[]
    disconnect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    delete?: officersWhereUniqueInput | officersWhereUniqueInput[]
    connect?: officersWhereUniqueInput | officersWhereUniqueInput[]
    update?: officersUpdateWithWhereUniqueWithoutPatrol_unitsInput | officersUpdateWithWhereUniqueWithoutPatrol_unitsInput[]
    updateMany?: officersUpdateManyWithWhereWithoutPatrol_unitsInput | officersUpdateManyWithWhereWithoutPatrol_unitsInput[]
    deleteMany?: officersScalarWhereInput | officersScalarWhereInput[]
  }

  export type patrol_unitsCreateNestedOneWithoutMembersInput = {
    create?: XOR<patrol_unitsCreateWithoutMembersInput, patrol_unitsUncheckedCreateWithoutMembersInput>
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutMembersInput
    connect?: patrol_unitsWhereUniqueInput
  }

  export type rolesCreateNestedOneWithoutOfficersInput = {
    create?: XOR<rolesCreateWithoutOfficersInput, rolesUncheckedCreateWithoutOfficersInput>
    connectOrCreate?: rolesCreateOrConnectWithoutOfficersInput
    connect?: rolesWhereUniqueInput
  }

  export type unitsCreateNestedOneWithoutOfficersInput = {
    connect?: unitsWhereUniqueInput
  }

  export type panic_button_logsCreateNestedManyWithoutOfficersInput = {
    create?: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput> | panic_button_logsCreateWithoutOfficersInput[] | panic_button_logsUncheckedCreateWithoutOfficersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutOfficersInput | panic_button_logsCreateOrConnectWithoutOfficersInput[]
    createMany?: panic_button_logsCreateManyOfficersInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type messagesCreateNestedManyWithoutSender_officerInput = {
    create?: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput> | messagesCreateWithoutSender_officerInput[] | messagesUncheckedCreateWithoutSender_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_officerInput | messagesCreateOrConnectWithoutSender_officerInput[]
    createMany?: messagesCreateManySender_officerInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type messagesCreateNestedManyWithoutRecipient_officerInput = {
    create?: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput> | messagesCreateWithoutRecipient_officerInput[] | messagesUncheckedCreateWithoutRecipient_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_officerInput | messagesCreateOrConnectWithoutRecipient_officerInput[]
    createMany?: messagesCreateManyRecipient_officerInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type inboxCreateNestedOneWithoutOfficerInput = {
    create?: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
    connectOrCreate?: inboxCreateOrConnectWithoutOfficerInput
    connect?: inboxWhereUniqueInput
  }

  export type panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput = {
    create?: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput> | panic_button_logsCreateWithoutOfficersInput[] | panic_button_logsUncheckedCreateWithoutOfficersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutOfficersInput | panic_button_logsCreateOrConnectWithoutOfficersInput[]
    createMany?: panic_button_logsCreateManyOfficersInputEnvelope
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
  }

  export type messagesUncheckedCreateNestedManyWithoutSender_officerInput = {
    create?: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput> | messagesCreateWithoutSender_officerInput[] | messagesUncheckedCreateWithoutSender_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_officerInput | messagesCreateOrConnectWithoutSender_officerInput[]
    createMany?: messagesCreateManySender_officerInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type messagesUncheckedCreateNestedManyWithoutRecipient_officerInput = {
    create?: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput> | messagesCreateWithoutRecipient_officerInput[] | messagesUncheckedCreateWithoutRecipient_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_officerInput | messagesCreateOrConnectWithoutRecipient_officerInput[]
    createMany?: messagesCreateManyRecipient_officerInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type inboxUncheckedCreateNestedOneWithoutOfficerInput = {
    create?: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
    connectOrCreate?: inboxCreateOrConnectWithoutOfficerInput
    connect?: inboxWhereUniqueInput
  }

  export type patrol_unitsUpdateOneWithoutMembersNestedInput = {
    create?: XOR<patrol_unitsCreateWithoutMembersInput, patrol_unitsUncheckedCreateWithoutMembersInput>
    connectOrCreate?: patrol_unitsCreateOrConnectWithoutMembersInput
    upsert?: patrol_unitsUpsertWithoutMembersInput
    disconnect?: patrol_unitsWhereInput | boolean
    delete?: patrol_unitsWhereInput | boolean
    connect?: patrol_unitsWhereUniqueInput
    update?: XOR<XOR<patrol_unitsUpdateToOneWithWhereWithoutMembersInput, patrol_unitsUpdateWithoutMembersInput>, patrol_unitsUncheckedUpdateWithoutMembersInput>
  }

  export type rolesUpdateOneRequiredWithoutOfficersNestedInput = {
    create?: XOR<rolesCreateWithoutOfficersInput, rolesUncheckedCreateWithoutOfficersInput>
    connectOrCreate?: rolesCreateOrConnectWithoutOfficersInput
    upsert?: rolesUpsertWithoutOfficersInput
    connect?: rolesWhereUniqueInput
    update?: XOR<XOR<rolesUpdateToOneWithWhereWithoutOfficersInput, rolesUpdateWithoutOfficersInput>, rolesUncheckedUpdateWithoutOfficersInput>
  }

  export type unitsUpdateOneWithoutOfficersNestedInput = {
    disconnect?: unitsWhereInput | boolean
    delete?: unitsWhereInput | boolean
    connect?: unitsWhereUniqueInput
    update?: XOR<XOR<unitsUpdateToOneWithWhereWithoutOfficersInput, unitsUpdateWithoutOfficersInput>, unitsUncheckedUpdateWithoutOfficersInput>
  }

  export type panic_button_logsUpdateManyWithoutOfficersNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput> | panic_button_logsCreateWithoutOfficersInput[] | panic_button_logsUncheckedCreateWithoutOfficersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutOfficersInput | panic_button_logsCreateOrConnectWithoutOfficersInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutOfficersInput | panic_button_logsUpsertWithWhereUniqueWithoutOfficersInput[]
    createMany?: panic_button_logsCreateManyOfficersInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutOfficersInput | panic_button_logsUpdateWithWhereUniqueWithoutOfficersInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutOfficersInput | panic_button_logsUpdateManyWithWhereWithoutOfficersInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type messagesUpdateManyWithoutSender_officerNestedInput = {
    create?: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput> | messagesCreateWithoutSender_officerInput[] | messagesUncheckedCreateWithoutSender_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_officerInput | messagesCreateOrConnectWithoutSender_officerInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutSender_officerInput | messagesUpsertWithWhereUniqueWithoutSender_officerInput[]
    createMany?: messagesCreateManySender_officerInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutSender_officerInput | messagesUpdateWithWhereUniqueWithoutSender_officerInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutSender_officerInput | messagesUpdateManyWithWhereWithoutSender_officerInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type messagesUpdateManyWithoutRecipient_officerNestedInput = {
    create?: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput> | messagesCreateWithoutRecipient_officerInput[] | messagesUncheckedCreateWithoutRecipient_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_officerInput | messagesCreateOrConnectWithoutRecipient_officerInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutRecipient_officerInput | messagesUpsertWithWhereUniqueWithoutRecipient_officerInput[]
    createMany?: messagesCreateManyRecipient_officerInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutRecipient_officerInput | messagesUpdateWithWhereUniqueWithoutRecipient_officerInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutRecipient_officerInput | messagesUpdateManyWithWhereWithoutRecipient_officerInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type inboxUpdateOneWithoutOfficerNestedInput = {
    create?: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
    connectOrCreate?: inboxCreateOrConnectWithoutOfficerInput
    upsert?: inboxUpsertWithoutOfficerInput
    disconnect?: inboxWhereInput | boolean
    delete?: inboxWhereInput | boolean
    connect?: inboxWhereUniqueInput
    update?: XOR<XOR<inboxUpdateToOneWithWhereWithoutOfficerInput, inboxUpdateWithoutOfficerInput>, inboxUncheckedUpdateWithoutOfficerInput>
  }

  export type panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput = {
    create?: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput> | panic_button_logsCreateWithoutOfficersInput[] | panic_button_logsUncheckedCreateWithoutOfficersInput[]
    connectOrCreate?: panic_button_logsCreateOrConnectWithoutOfficersInput | panic_button_logsCreateOrConnectWithoutOfficersInput[]
    upsert?: panic_button_logsUpsertWithWhereUniqueWithoutOfficersInput | panic_button_logsUpsertWithWhereUniqueWithoutOfficersInput[]
    createMany?: panic_button_logsCreateManyOfficersInputEnvelope
    set?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    disconnect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    delete?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    connect?: panic_button_logsWhereUniqueInput | panic_button_logsWhereUniqueInput[]
    update?: panic_button_logsUpdateWithWhereUniqueWithoutOfficersInput | panic_button_logsUpdateWithWhereUniqueWithoutOfficersInput[]
    updateMany?: panic_button_logsUpdateManyWithWhereWithoutOfficersInput | panic_button_logsUpdateManyWithWhereWithoutOfficersInput[]
    deleteMany?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
  }

  export type messagesUncheckedUpdateManyWithoutSender_officerNestedInput = {
    create?: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput> | messagesCreateWithoutSender_officerInput[] | messagesUncheckedCreateWithoutSender_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutSender_officerInput | messagesCreateOrConnectWithoutSender_officerInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutSender_officerInput | messagesUpsertWithWhereUniqueWithoutSender_officerInput[]
    createMany?: messagesCreateManySender_officerInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutSender_officerInput | messagesUpdateWithWhereUniqueWithoutSender_officerInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutSender_officerInput | messagesUpdateManyWithWhereWithoutSender_officerInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput = {
    create?: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput> | messagesCreateWithoutRecipient_officerInput[] | messagesUncheckedCreateWithoutRecipient_officerInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutRecipient_officerInput | messagesCreateOrConnectWithoutRecipient_officerInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutRecipient_officerInput | messagesUpsertWithWhereUniqueWithoutRecipient_officerInput[]
    createMany?: messagesCreateManyRecipient_officerInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutRecipient_officerInput | messagesUpdateWithWhereUniqueWithoutRecipient_officerInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutRecipient_officerInput | messagesUpdateManyWithWhereWithoutRecipient_officerInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type inboxUncheckedUpdateOneWithoutOfficerNestedInput = {
    create?: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
    connectOrCreate?: inboxCreateOrConnectWithoutOfficerInput
    upsert?: inboxUpsertWithoutOfficerInput
    disconnect?: inboxWhereInput | boolean
    delete?: inboxWhereInput | boolean
    connect?: inboxWhereUniqueInput
    update?: XOR<XOR<inboxUpdateToOneWithWhereWithoutOfficerInput, inboxUpdateWithoutOfficerInput>, inboxUncheckedUpdateWithoutOfficerInput>
  }

  export type unitsCreateNestedOneWithoutUnit_statisticsInput = {
    connect?: unitsWhereUniqueInput
  }

  export type unitsUpdateOneRequiredWithoutUnit_statisticsNestedInput = {
    connect?: unitsWhereUniqueInput
    update?: XOR<XOR<unitsUpdateToOneWithWhereWithoutUnit_statisticsInput, unitsUpdateWithoutUnit_statisticsInput>, unitsUncheckedUpdateWithoutUnit_statisticsInput>
  }

  export type districtsUpdateOneRequiredWithoutGeographicsNestedInput = {
    create?: XOR<districtsCreateWithoutGeographicsInput, districtsUncheckedCreateWithoutGeographicsInput>
    connectOrCreate?: districtsCreateOrConnectWithoutGeographicsInput
    upsert?: districtsUpsertWithoutGeographicsInput
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutGeographicsInput, districtsUpdateWithoutGeographicsInput>, districtsUncheckedUpdateWithoutGeographicsInput>
  }

  export type Enumstatus_messagesFieldUpdateOperationsInput = {
    set?: $Enums.status_messages
  }

  export type usersCreateNestedOneWithoutSentMessagesInput = {
    create?: XOR<usersCreateWithoutSentMessagesInput, usersUncheckedCreateWithoutSentMessagesInput>
    connectOrCreate?: usersCreateOrConnectWithoutSentMessagesInput
    connect?: usersWhereUniqueInput
  }

  export type officersCreateNestedOneWithoutSentMessagesInput = {
    create?: XOR<officersCreateWithoutSentMessagesInput, officersUncheckedCreateWithoutSentMessagesInput>
    connectOrCreate?: officersCreateOrConnectWithoutSentMessagesInput
    connect?: officersWhereUniqueInput
  }

  export type usersCreateNestedOneWithoutReceivedMessagesInput = {
    create?: XOR<usersCreateWithoutReceivedMessagesInput, usersUncheckedCreateWithoutReceivedMessagesInput>
    connectOrCreate?: usersCreateOrConnectWithoutReceivedMessagesInput
    connect?: usersWhereUniqueInput
  }

  export type officersCreateNestedOneWithoutReceivedMessagesInput = {
    create?: XOR<officersCreateWithoutReceivedMessagesInput, officersUncheckedCreateWithoutReceivedMessagesInput>
    connectOrCreate?: officersCreateOrConnectWithoutReceivedMessagesInput
    connect?: officersWhereUniqueInput
  }

  export type inboxCreateNestedOneWithoutMessagesInput = {
    create?: XOR<inboxCreateWithoutMessagesInput, inboxUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: inboxCreateOrConnectWithoutMessagesInput
    connect?: inboxWhereUniqueInput
  }

  export type usersUpdateOneWithoutSentMessagesNestedInput = {
    create?: XOR<usersCreateWithoutSentMessagesInput, usersUncheckedCreateWithoutSentMessagesInput>
    connectOrCreate?: usersCreateOrConnectWithoutSentMessagesInput
    upsert?: usersUpsertWithoutSentMessagesInput
    disconnect?: usersWhereInput | boolean
    delete?: usersWhereInput | boolean
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutSentMessagesInput, usersUpdateWithoutSentMessagesInput>, usersUncheckedUpdateWithoutSentMessagesInput>
  }

  export type officersUpdateOneWithoutSentMessagesNestedInput = {
    create?: XOR<officersCreateWithoutSentMessagesInput, officersUncheckedCreateWithoutSentMessagesInput>
    connectOrCreate?: officersCreateOrConnectWithoutSentMessagesInput
    upsert?: officersUpsertWithoutSentMessagesInput
    disconnect?: officersWhereInput | boolean
    delete?: officersWhereInput | boolean
    connect?: officersWhereUniqueInput
    update?: XOR<XOR<officersUpdateToOneWithWhereWithoutSentMessagesInput, officersUpdateWithoutSentMessagesInput>, officersUncheckedUpdateWithoutSentMessagesInput>
  }

  export type usersUpdateOneWithoutReceivedMessagesNestedInput = {
    create?: XOR<usersCreateWithoutReceivedMessagesInput, usersUncheckedCreateWithoutReceivedMessagesInput>
    connectOrCreate?: usersCreateOrConnectWithoutReceivedMessagesInput
    upsert?: usersUpsertWithoutReceivedMessagesInput
    disconnect?: usersWhereInput | boolean
    delete?: usersWhereInput | boolean
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutReceivedMessagesInput, usersUpdateWithoutReceivedMessagesInput>, usersUncheckedUpdateWithoutReceivedMessagesInput>
  }

  export type officersUpdateOneWithoutReceivedMessagesNestedInput = {
    create?: XOR<officersCreateWithoutReceivedMessagesInput, officersUncheckedCreateWithoutReceivedMessagesInput>
    connectOrCreate?: officersCreateOrConnectWithoutReceivedMessagesInput
    upsert?: officersUpsertWithoutReceivedMessagesInput
    disconnect?: officersWhereInput | boolean
    delete?: officersWhereInput | boolean
    connect?: officersWhereUniqueInput
    update?: XOR<XOR<officersUpdateToOneWithWhereWithoutReceivedMessagesInput, officersUpdateWithoutReceivedMessagesInput>, officersUncheckedUpdateWithoutReceivedMessagesInput>
  }

  export type inboxUpdateOneWithoutMessagesNestedInput = {
    create?: XOR<inboxCreateWithoutMessagesInput, inboxUncheckedCreateWithoutMessagesInput>
    connectOrCreate?: inboxCreateOrConnectWithoutMessagesInput
    upsert?: inboxUpsertWithoutMessagesInput
    disconnect?: inboxWhereInput | boolean
    delete?: inboxWhereInput | boolean
    connect?: inboxWhereUniqueInput
    update?: XOR<XOR<inboxUpdateToOneWithWhereWithoutMessagesInput, inboxUpdateWithoutMessagesInput>, inboxUncheckedUpdateWithoutMessagesInput>
  }

  export type usersCreateNestedOneWithoutInboxInput = {
    create?: XOR<usersCreateWithoutInboxInput, usersUncheckedCreateWithoutInboxInput>
    connectOrCreate?: usersCreateOrConnectWithoutInboxInput
    connect?: usersWhereUniqueInput
  }

  export type officersCreateNestedOneWithoutInboxInput = {
    create?: XOR<officersCreateWithoutInboxInput, officersUncheckedCreateWithoutInboxInput>
    connectOrCreate?: officersCreateOrConnectWithoutInboxInput
    connect?: officersWhereUniqueInput
  }

  export type messagesCreateNestedManyWithoutInboxInput = {
    create?: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput> | messagesCreateWithoutInboxInput[] | messagesUncheckedCreateWithoutInboxInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutInboxInput | messagesCreateOrConnectWithoutInboxInput[]
    createMany?: messagesCreateManyInboxInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type messagesUncheckedCreateNestedManyWithoutInboxInput = {
    create?: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput> | messagesCreateWithoutInboxInput[] | messagesUncheckedCreateWithoutInboxInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutInboxInput | messagesCreateOrConnectWithoutInboxInput[]
    createMany?: messagesCreateManyInboxInputEnvelope
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
  }

  export type usersUpdateOneRequiredWithoutInboxNestedInput = {
    create?: XOR<usersCreateWithoutInboxInput, usersUncheckedCreateWithoutInboxInput>
    connectOrCreate?: usersCreateOrConnectWithoutInboxInput
    upsert?: usersUpsertWithoutInboxInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutInboxInput, usersUpdateWithoutInboxInput>, usersUncheckedUpdateWithoutInboxInput>
  }

  export type officersUpdateOneRequiredWithoutInboxNestedInput = {
    create?: XOR<officersCreateWithoutInboxInput, officersUncheckedCreateWithoutInboxInput>
    connectOrCreate?: officersCreateOrConnectWithoutInboxInput
    upsert?: officersUpsertWithoutInboxInput
    connect?: officersWhereUniqueInput
    update?: XOR<XOR<officersUpdateToOneWithWhereWithoutInboxInput, officersUpdateWithoutInboxInput>, officersUncheckedUpdateWithoutInboxInput>
  }

  export type messagesUpdateManyWithoutInboxNestedInput = {
    create?: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput> | messagesCreateWithoutInboxInput[] | messagesUncheckedCreateWithoutInboxInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutInboxInput | messagesCreateOrConnectWithoutInboxInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutInboxInput | messagesUpsertWithWhereUniqueWithoutInboxInput[]
    createMany?: messagesCreateManyInboxInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutInboxInput | messagesUpdateWithWhereUniqueWithoutInboxInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutInboxInput | messagesUpdateManyWithWhereWithoutInboxInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type messagesUncheckedUpdateManyWithoutInboxNestedInput = {
    create?: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput> | messagesCreateWithoutInboxInput[] | messagesUncheckedCreateWithoutInboxInput[]
    connectOrCreate?: messagesCreateOrConnectWithoutInboxInput | messagesCreateOrConnectWithoutInboxInput[]
    upsert?: messagesUpsertWithWhereUniqueWithoutInboxInput | messagesUpsertWithWhereUniqueWithoutInboxInput[]
    createMany?: messagesCreateManyInboxInputEnvelope
    set?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    disconnect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    delete?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    connect?: messagesWhereUniqueInput | messagesWhereUniqueInput[]
    update?: messagesUpdateWithWhereUniqueWithoutInboxInput | messagesUpdateWithWhereUniqueWithoutInboxInput[]
    updateMany?: messagesUpdateManyWithWhereWithoutInboxInput | messagesUpdateManyWithWhereWithoutInboxInput[]
    deleteMany?: messagesScalarWhereInput | messagesScalarWhereInput[]
  }

  export type incident_logsCreateNestedOneWithoutPanic_button_logsInput = {
    create?: XOR<incident_logsCreateWithoutPanic_button_logsInput, incident_logsUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutPanic_button_logsInput
    connect?: incident_logsWhereUniqueInput
  }

  export type officersCreateNestedOneWithoutPanic_button_logsInput = {
    create?: XOR<officersCreateWithoutPanic_button_logsInput, officersUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: officersCreateOrConnectWithoutPanic_button_logsInput
    connect?: officersWhereUniqueInput
  }

  export type usersCreateNestedOneWithoutPanic_button_logsInput = {
    create?: XOR<usersCreateWithoutPanic_button_logsInput, usersUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: usersCreateOrConnectWithoutPanic_button_logsInput
    connect?: usersWhereUniqueInput
  }

  export type incident_logsUpdateOneRequiredWithoutPanic_button_logsNestedInput = {
    create?: XOR<incident_logsCreateWithoutPanic_button_logsInput, incident_logsUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: incident_logsCreateOrConnectWithoutPanic_button_logsInput
    upsert?: incident_logsUpsertWithoutPanic_button_logsInput
    connect?: incident_logsWhereUniqueInput
    update?: XOR<XOR<incident_logsUpdateToOneWithWhereWithoutPanic_button_logsInput, incident_logsUpdateWithoutPanic_button_logsInput>, incident_logsUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type officersUpdateOneWithoutPanic_button_logsNestedInput = {
    create?: XOR<officersCreateWithoutPanic_button_logsInput, officersUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: officersCreateOrConnectWithoutPanic_button_logsInput
    upsert?: officersUpsertWithoutPanic_button_logsInput
    disconnect?: officersWhereInput | boolean
    delete?: officersWhereInput | boolean
    connect?: officersWhereUniqueInput
    update?: XOR<XOR<officersUpdateToOneWithWhereWithoutPanic_button_logsInput, officersUpdateWithoutPanic_button_logsInput>, officersUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type usersUpdateOneRequiredWithoutPanic_button_logsNestedInput = {
    create?: XOR<usersCreateWithoutPanic_button_logsInput, usersUncheckedCreateWithoutPanic_button_logsInput>
    connectOrCreate?: usersCreateOrConnectWithoutPanic_button_logsInput
    upsert?: usersUpsertWithoutPanic_button_logsInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutPanic_button_logsInput, usersUpdateWithoutPanic_button_logsInput>, usersUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type locationsUpdateOneRequiredWithoutLocation_logsNestedInput = {
    connect?: locationsWhereUniqueInput
    update?: XOR<XOR<locationsUpdateToOneWithWhereWithoutLocation_logsInput, locationsUpdateWithoutLocation_logsInput>, locationsUncheckedUpdateWithoutLocation_logsInput>
  }

  export type districtsCreateNestedOneWithoutDistrict_clustersInput = {
    create?: XOR<districtsCreateWithoutDistrict_clustersInput, districtsUncheckedCreateWithoutDistrict_clustersInput>
    connectOrCreate?: districtsCreateOrConnectWithoutDistrict_clustersInput
    connect?: districtsWhereUniqueInput
  }

  export type districtsUpdateOneRequiredWithoutDistrict_clustersNestedInput = {
    create?: XOR<districtsCreateWithoutDistrict_clustersInput, districtsUncheckedCreateWithoutDistrict_clustersInput>
    connectOrCreate?: districtsCreateOrConnectWithoutDistrict_clustersInput
    upsert?: districtsUpsertWithoutDistrict_clustersInput
    connect?: districtsWhereUniqueInput
    update?: XOR<XOR<districtsUpdateToOneWithWhereWithoutDistrict_clustersInput, districtsUpdateWithoutDistrict_clustersInput>, districtsUncheckedUpdateWithoutDistrict_clustersInput>
  }

  export type usersCreateNestedOneWithoutTaskInput = {
    create?: XOR<usersCreateWithoutTaskInput, usersUncheckedCreateWithoutTaskInput>
    connectOrCreate?: usersCreateOrConnectWithoutTaskInput
    connect?: usersWhereUniqueInput
  }

  export type Enumtask_statusFieldUpdateOperationsInput = {
    set?: $Enums.task_status
  }

  export type Enumtask_labelFieldUpdateOperationsInput = {
    set?: $Enums.task_label
  }

  export type Enumtask_priorityFieldUpdateOperationsInput = {
    set?: $Enums.task_priority
  }

  export type usersUpdateOneRequiredWithoutTaskNestedInput = {
    create?: XOR<usersCreateWithoutTaskInput, usersUncheckedCreateWithoutTaskInput>
    connectOrCreate?: usersCreateOrConnectWithoutTaskInput
    upsert?: usersUpsertWithoutTaskInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutTaskInput, usersUpdateWithoutTaskInput>, usersUncheckedUpdateWithoutTaskInput>
  }

  export type usersCreateNestedOneWithoutProjectsInput = {
    create?: XOR<usersCreateWithoutProjectsInput, usersUncheckedCreateWithoutProjectsInput>
    connectOrCreate?: usersCreateOrConnectWithoutProjectsInput
    connect?: usersWhereUniqueInput
  }

  export type datasetsCreateNestedManyWithoutProjectsInput = {
    create?: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput> | datasetsCreateWithoutProjectsInput[] | datasetsUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: datasetsCreateOrConnectWithoutProjectsInput | datasetsCreateOrConnectWithoutProjectsInput[]
    createMany?: datasetsCreateManyProjectsInputEnvelope
    connect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
  }

  export type analysesCreateNestedManyWithoutProjectsInput = {
    create?: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput> | analysesCreateWithoutProjectsInput[] | analysesUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutProjectsInput | analysesCreateOrConnectWithoutProjectsInput[]
    createMany?: analysesCreateManyProjectsInputEnvelope
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
  }

  export type datasetsUncheckedCreateNestedManyWithoutProjectsInput = {
    create?: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput> | datasetsCreateWithoutProjectsInput[] | datasetsUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: datasetsCreateOrConnectWithoutProjectsInput | datasetsCreateOrConnectWithoutProjectsInput[]
    createMany?: datasetsCreateManyProjectsInputEnvelope
    connect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
  }

  export type analysesUncheckedCreateNestedManyWithoutProjectsInput = {
    create?: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput> | analysesCreateWithoutProjectsInput[] | analysesUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutProjectsInput | analysesCreateOrConnectWithoutProjectsInput[]
    createMany?: analysesCreateManyProjectsInputEnvelope
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
  }

  export type usersUpdateOneRequiredWithoutProjectsNestedInput = {
    create?: XOR<usersCreateWithoutProjectsInput, usersUncheckedCreateWithoutProjectsInput>
    connectOrCreate?: usersCreateOrConnectWithoutProjectsInput
    upsert?: usersUpsertWithoutProjectsInput
    connect?: usersWhereUniqueInput
    update?: XOR<XOR<usersUpdateToOneWithWhereWithoutProjectsInput, usersUpdateWithoutProjectsInput>, usersUncheckedUpdateWithoutProjectsInput>
  }

  export type datasetsUpdateManyWithoutProjectsNestedInput = {
    create?: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput> | datasetsCreateWithoutProjectsInput[] | datasetsUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: datasetsCreateOrConnectWithoutProjectsInput | datasetsCreateOrConnectWithoutProjectsInput[]
    upsert?: datasetsUpsertWithWhereUniqueWithoutProjectsInput | datasetsUpsertWithWhereUniqueWithoutProjectsInput[]
    createMany?: datasetsCreateManyProjectsInputEnvelope
    set?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    disconnect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    delete?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    connect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    update?: datasetsUpdateWithWhereUniqueWithoutProjectsInput | datasetsUpdateWithWhereUniqueWithoutProjectsInput[]
    updateMany?: datasetsUpdateManyWithWhereWithoutProjectsInput | datasetsUpdateManyWithWhereWithoutProjectsInput[]
    deleteMany?: datasetsScalarWhereInput | datasetsScalarWhereInput[]
  }

  export type analysesUpdateManyWithoutProjectsNestedInput = {
    create?: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput> | analysesCreateWithoutProjectsInput[] | analysesUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutProjectsInput | analysesCreateOrConnectWithoutProjectsInput[]
    upsert?: analysesUpsertWithWhereUniqueWithoutProjectsInput | analysesUpsertWithWhereUniqueWithoutProjectsInput[]
    createMany?: analysesCreateManyProjectsInputEnvelope
    set?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    disconnect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    delete?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    update?: analysesUpdateWithWhereUniqueWithoutProjectsInput | analysesUpdateWithWhereUniqueWithoutProjectsInput[]
    updateMany?: analysesUpdateManyWithWhereWithoutProjectsInput | analysesUpdateManyWithWhereWithoutProjectsInput[]
    deleteMany?: analysesScalarWhereInput | analysesScalarWhereInput[]
  }

  export type datasetsUncheckedUpdateManyWithoutProjectsNestedInput = {
    create?: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput> | datasetsCreateWithoutProjectsInput[] | datasetsUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: datasetsCreateOrConnectWithoutProjectsInput | datasetsCreateOrConnectWithoutProjectsInput[]
    upsert?: datasetsUpsertWithWhereUniqueWithoutProjectsInput | datasetsUpsertWithWhereUniqueWithoutProjectsInput[]
    createMany?: datasetsCreateManyProjectsInputEnvelope
    set?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    disconnect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    delete?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    connect?: datasetsWhereUniqueInput | datasetsWhereUniqueInput[]
    update?: datasetsUpdateWithWhereUniqueWithoutProjectsInput | datasetsUpdateWithWhereUniqueWithoutProjectsInput[]
    updateMany?: datasetsUpdateManyWithWhereWithoutProjectsInput | datasetsUpdateManyWithWhereWithoutProjectsInput[]
    deleteMany?: datasetsScalarWhereInput | datasetsScalarWhereInput[]
  }

  export type analysesUncheckedUpdateManyWithoutProjectsNestedInput = {
    create?: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput> | analysesCreateWithoutProjectsInput[] | analysesUncheckedCreateWithoutProjectsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutProjectsInput | analysesCreateOrConnectWithoutProjectsInput[]
    upsert?: analysesUpsertWithWhereUniqueWithoutProjectsInput | analysesUpsertWithWhereUniqueWithoutProjectsInput[]
    createMany?: analysesCreateManyProjectsInputEnvelope
    set?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    disconnect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    delete?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    update?: analysesUpdateWithWhereUniqueWithoutProjectsInput | analysesUpdateWithWhereUniqueWithoutProjectsInput[]
    updateMany?: analysesUpdateManyWithWhereWithoutProjectsInput | analysesUpdateManyWithWhereWithoutProjectsInput[]
    deleteMany?: analysesScalarWhereInput | analysesScalarWhereInput[]
  }

  export type projectsCreateNestedOneWithoutDatasetsInput = {
    create?: XOR<projectsCreateWithoutDatasetsInput, projectsUncheckedCreateWithoutDatasetsInput>
    connectOrCreate?: projectsCreateOrConnectWithoutDatasetsInput
    connect?: projectsWhereUniqueInput
  }

  export type analysesCreateNestedManyWithoutDatasetsInput = {
    create?: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput> | analysesCreateWithoutDatasetsInput[] | analysesUncheckedCreateWithoutDatasetsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutDatasetsInput | analysesCreateOrConnectWithoutDatasetsInput[]
    createMany?: analysesCreateManyDatasetsInputEnvelope
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
  }

  export type analysesUncheckedCreateNestedManyWithoutDatasetsInput = {
    create?: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput> | analysesCreateWithoutDatasetsInput[] | analysesUncheckedCreateWithoutDatasetsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutDatasetsInput | analysesCreateOrConnectWithoutDatasetsInput[]
    createMany?: analysesCreateManyDatasetsInputEnvelope
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
  }

  export type projectsUpdateOneRequiredWithoutDatasetsNestedInput = {
    create?: XOR<projectsCreateWithoutDatasetsInput, projectsUncheckedCreateWithoutDatasetsInput>
    connectOrCreate?: projectsCreateOrConnectWithoutDatasetsInput
    upsert?: projectsUpsertWithoutDatasetsInput
    connect?: projectsWhereUniqueInput
    update?: XOR<XOR<projectsUpdateToOneWithWhereWithoutDatasetsInput, projectsUpdateWithoutDatasetsInput>, projectsUncheckedUpdateWithoutDatasetsInput>
  }

  export type analysesUpdateManyWithoutDatasetsNestedInput = {
    create?: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput> | analysesCreateWithoutDatasetsInput[] | analysesUncheckedCreateWithoutDatasetsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutDatasetsInput | analysesCreateOrConnectWithoutDatasetsInput[]
    upsert?: analysesUpsertWithWhereUniqueWithoutDatasetsInput | analysesUpsertWithWhereUniqueWithoutDatasetsInput[]
    createMany?: analysesCreateManyDatasetsInputEnvelope
    set?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    disconnect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    delete?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    update?: analysesUpdateWithWhereUniqueWithoutDatasetsInput | analysesUpdateWithWhereUniqueWithoutDatasetsInput[]
    updateMany?: analysesUpdateManyWithWhereWithoutDatasetsInput | analysesUpdateManyWithWhereWithoutDatasetsInput[]
    deleteMany?: analysesScalarWhereInput | analysesScalarWhereInput[]
  }

  export type analysesUncheckedUpdateManyWithoutDatasetsNestedInput = {
    create?: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput> | analysesCreateWithoutDatasetsInput[] | analysesUncheckedCreateWithoutDatasetsInput[]
    connectOrCreate?: analysesCreateOrConnectWithoutDatasetsInput | analysesCreateOrConnectWithoutDatasetsInput[]
    upsert?: analysesUpsertWithWhereUniqueWithoutDatasetsInput | analysesUpsertWithWhereUniqueWithoutDatasetsInput[]
    createMany?: analysesCreateManyDatasetsInputEnvelope
    set?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    disconnect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    delete?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    connect?: analysesWhereUniqueInput | analysesWhereUniqueInput[]
    update?: analysesUpdateWithWhereUniqueWithoutDatasetsInput | analysesUpdateWithWhereUniqueWithoutDatasetsInput[]
    updateMany?: analysesUpdateManyWithWhereWithoutDatasetsInput | analysesUpdateManyWithWhereWithoutDatasetsInput[]
    deleteMany?: analysesScalarWhereInput | analysesScalarWhereInput[]
  }

  export type projectsCreateNestedOneWithoutAnalysesInput = {
    create?: XOR<projectsCreateWithoutAnalysesInput, projectsUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: projectsCreateOrConnectWithoutAnalysesInput
    connect?: projectsWhereUniqueInput
  }

  export type datasetsCreateNestedOneWithoutAnalysesInput = {
    create?: XOR<datasetsCreateWithoutAnalysesInput, datasetsUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: datasetsCreateOrConnectWithoutAnalysesInput
    connect?: datasetsWhereUniqueInput
  }

  export type clustersCreateNestedManyWithoutAnalysesInput = {
    create?: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput> | clustersCreateWithoutAnalysesInput[] | clustersUncheckedCreateWithoutAnalysesInput[]
    connectOrCreate?: clustersCreateOrConnectWithoutAnalysesInput | clustersCreateOrConnectWithoutAnalysesInput[]
    createMany?: clustersCreateManyAnalysesInputEnvelope
    connect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
  }

  export type clustersUncheckedCreateNestedManyWithoutAnalysesInput = {
    create?: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput> | clustersCreateWithoutAnalysesInput[] | clustersUncheckedCreateWithoutAnalysesInput[]
    connectOrCreate?: clustersCreateOrConnectWithoutAnalysesInput | clustersCreateOrConnectWithoutAnalysesInput[]
    createMany?: clustersCreateManyAnalysesInputEnvelope
    connect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
  }

  export type projectsUpdateOneRequiredWithoutAnalysesNestedInput = {
    create?: XOR<projectsCreateWithoutAnalysesInput, projectsUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: projectsCreateOrConnectWithoutAnalysesInput
    upsert?: projectsUpsertWithoutAnalysesInput
    connect?: projectsWhereUniqueInput
    update?: XOR<XOR<projectsUpdateToOneWithWhereWithoutAnalysesInput, projectsUpdateWithoutAnalysesInput>, projectsUncheckedUpdateWithoutAnalysesInput>
  }

  export type datasetsUpdateOneRequiredWithoutAnalysesNestedInput = {
    create?: XOR<datasetsCreateWithoutAnalysesInput, datasetsUncheckedCreateWithoutAnalysesInput>
    connectOrCreate?: datasetsCreateOrConnectWithoutAnalysesInput
    upsert?: datasetsUpsertWithoutAnalysesInput
    connect?: datasetsWhereUniqueInput
    update?: XOR<XOR<datasetsUpdateToOneWithWhereWithoutAnalysesInput, datasetsUpdateWithoutAnalysesInput>, datasetsUncheckedUpdateWithoutAnalysesInput>
  }

  export type clustersUpdateManyWithoutAnalysesNestedInput = {
    create?: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput> | clustersCreateWithoutAnalysesInput[] | clustersUncheckedCreateWithoutAnalysesInput[]
    connectOrCreate?: clustersCreateOrConnectWithoutAnalysesInput | clustersCreateOrConnectWithoutAnalysesInput[]
    upsert?: clustersUpsertWithWhereUniqueWithoutAnalysesInput | clustersUpsertWithWhereUniqueWithoutAnalysesInput[]
    createMany?: clustersCreateManyAnalysesInputEnvelope
    set?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    disconnect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    delete?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    connect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    update?: clustersUpdateWithWhereUniqueWithoutAnalysesInput | clustersUpdateWithWhereUniqueWithoutAnalysesInput[]
    updateMany?: clustersUpdateManyWithWhereWithoutAnalysesInput | clustersUpdateManyWithWhereWithoutAnalysesInput[]
    deleteMany?: clustersScalarWhereInput | clustersScalarWhereInput[]
  }

  export type clustersUncheckedUpdateManyWithoutAnalysesNestedInput = {
    create?: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput> | clustersCreateWithoutAnalysesInput[] | clustersUncheckedCreateWithoutAnalysesInput[]
    connectOrCreate?: clustersCreateOrConnectWithoutAnalysesInput | clustersCreateOrConnectWithoutAnalysesInput[]
    upsert?: clustersUpsertWithWhereUniqueWithoutAnalysesInput | clustersUpsertWithWhereUniqueWithoutAnalysesInput[]
    createMany?: clustersCreateManyAnalysesInputEnvelope
    set?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    disconnect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    delete?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    connect?: clustersWhereUniqueInput | clustersWhereUniqueInput[]
    update?: clustersUpdateWithWhereUniqueWithoutAnalysesInput | clustersUpdateWithWhereUniqueWithoutAnalysesInput[]
    updateMany?: clustersUpdateManyWithWhereWithoutAnalysesInput | clustersUpdateManyWithWhereWithoutAnalysesInput[]
    deleteMany?: clustersScalarWhereInput | clustersScalarWhereInput[]
  }

  export type analysesCreateNestedOneWithoutClustersInput = {
    create?: XOR<analysesCreateWithoutClustersInput, analysesUncheckedCreateWithoutClustersInput>
    connectOrCreate?: analysesCreateOrConnectWithoutClustersInput
    connect?: analysesWhereUniqueInput
  }

  export type analysesUpdateOneRequiredWithoutClustersNestedInput = {
    create?: XOR<analysesCreateWithoutClustersInput, analysesUncheckedCreateWithoutClustersInput>
    connectOrCreate?: analysesCreateOrConnectWithoutClustersInput
    upsert?: analysesUpsertWithoutClustersInput
    connect?: analysesWhereUniqueInput
    update?: XOR<XOR<analysesUpdateToOneWithWhereWithoutClustersInput, analysesUpdateWithoutClustersInput>, analysesUncheckedUpdateWithoutClustersInput>
  }

  export type NestedUuidFilter<$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>
    not?: NestedUuidFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type 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 NestedUuidWithAggregatesFilter<$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>
    not?: NestedUuidWithAggregatesFilter<$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 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 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 NestedJsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type 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 NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type 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 NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type 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 NestedEnumsession_statusFilter<$PrismaModel = never> = {
    equals?: $Enums.session_status | Enumsession_statusFieldRefInput<$PrismaModel>
    in?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumsession_statusFilter<$PrismaModel> | $Enums.session_status
  }

  export type NestedEnumsession_statusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.session_status | Enumsession_statusFieldRefInput<$PrismaModel>
    in?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.session_status[] | ListEnumsession_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumsession_statusWithAggregatesFilter<$PrismaModel> | $Enums.session_status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumsession_statusFilter<$PrismaModel>
    _max?: NestedEnumsession_statusFilter<$PrismaModel>
  }

  export type NestedEnumcrime_statusNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_status | Enumcrime_statusFieldRefInput<$PrismaModel> | null
    in?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumcrime_statusNullableFilter<$PrismaModel> | $Enums.crime_status | null
  }

  export type NestedEnumcrime_statusNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_status | Enumcrime_statusFieldRefInput<$PrismaModel> | null
    in?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.crime_status[] | ListEnumcrime_statusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumcrime_statusNullableWithAggregatesFilter<$PrismaModel> | $Enums.crime_status | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumcrime_statusNullableFilter<$PrismaModel>
    _max?: NestedEnumcrime_statusNullableFilter<$PrismaModel>
  }

  export type NestedEnumcrime_ratesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_rates | Enumcrime_ratesFieldRefInput<$PrismaModel>
    in?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    notIn?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    not?: NestedEnumcrime_ratesFilter<$PrismaModel> | $Enums.crime_rates
  }

  export type NestedEnumcrime_ratesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.crime_rates | Enumcrime_ratesFieldRefInput<$PrismaModel>
    in?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    notIn?: $Enums.crime_rates[] | ListEnumcrime_ratesFieldRefInput<$PrismaModel>
    not?: NestedEnumcrime_ratesWithAggregatesFilter<$PrismaModel> | $Enums.crime_rates
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumcrime_ratesFilter<$PrismaModel>
    _max?: NestedEnumcrime_ratesFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedFloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedBoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | 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 NestedUuidNullableFilter<$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>
    not?: NestedUuidNullableFilter<$PrismaModel> | string | null
  }

  export type NestedUuidNullableWithAggregatesFilter<$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>
    not?: NestedUuidNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedEnumunit_typeFilter<$PrismaModel = never> = {
    equals?: $Enums.unit_type | Enumunit_typeFieldRefInput<$PrismaModel>
    in?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    notIn?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    not?: NestedEnumunit_typeFilter<$PrismaModel> | $Enums.unit_type
  }

  export type NestedEnumunit_typeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.unit_type | Enumunit_typeFieldRefInput<$PrismaModel>
    in?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    notIn?: $Enums.unit_type[] | ListEnumunit_typeFieldRefInput<$PrismaModel>
    not?: NestedEnumunit_typeWithAggregatesFilter<$PrismaModel> | $Enums.unit_type
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumunit_typeFilter<$PrismaModel>
    _max?: NestedEnumunit_typeFilter<$PrismaModel>
  }

  export type NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.patrol_unit_category | Enumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    in?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    not?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel> | $Enums.patrol_unit_category | null
  }

  export type NestedEnumpatrol_unit_categoryNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.patrol_unit_category | Enumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    in?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.patrol_unit_category[] | ListEnumpatrol_unit_categoryFieldRefInput<$PrismaModel> | null
    not?: NestedEnumpatrol_unit_categoryNullableWithAggregatesFilter<$PrismaModel> | $Enums.patrol_unit_category | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel>
    _max?: NestedEnumpatrol_unit_categoryNullableFilter<$PrismaModel>
  }

  export type NestedEnumstatus_messagesFilter<$PrismaModel = never> = {
    equals?: $Enums.status_messages | Enumstatus_messagesFieldRefInput<$PrismaModel>
    in?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    notIn?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    not?: NestedEnumstatus_messagesFilter<$PrismaModel> | $Enums.status_messages
  }

  export type NestedEnumstatus_messagesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.status_messages | Enumstatus_messagesFieldRefInput<$PrismaModel>
    in?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    notIn?: $Enums.status_messages[] | ListEnumstatus_messagesFieldRefInput<$PrismaModel>
    not?: NestedEnumstatus_messagesWithAggregatesFilter<$PrismaModel> | $Enums.status_messages
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumstatus_messagesFilter<$PrismaModel>
    _max?: NestedEnumstatus_messagesFilter<$PrismaModel>
  }

  export type NestedEnumtask_statusFilter<$PrismaModel = never> = {
    equals?: $Enums.task_status | Enumtask_statusFieldRefInput<$PrismaModel>
    in?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_statusFilter<$PrismaModel> | $Enums.task_status
  }

  export type NestedEnumtask_labelFilter<$PrismaModel = never> = {
    equals?: $Enums.task_label | Enumtask_labelFieldRefInput<$PrismaModel>
    in?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_labelFilter<$PrismaModel> | $Enums.task_label
  }

  export type NestedEnumtask_priorityFilter<$PrismaModel = never> = {
    equals?: $Enums.task_priority | Enumtask_priorityFieldRefInput<$PrismaModel>
    in?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_priorityFilter<$PrismaModel> | $Enums.task_priority
  }

  export type NestedEnumtask_statusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_status | Enumtask_statusFieldRefInput<$PrismaModel>
    in?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_status[] | ListEnumtask_statusFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_statusWithAggregatesFilter<$PrismaModel> | $Enums.task_status
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_statusFilter<$PrismaModel>
    _max?: NestedEnumtask_statusFilter<$PrismaModel>
  }

  export type NestedEnumtask_labelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_label | Enumtask_labelFieldRefInput<$PrismaModel>
    in?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_label[] | ListEnumtask_labelFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_labelWithAggregatesFilter<$PrismaModel> | $Enums.task_label
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_labelFilter<$PrismaModel>
    _max?: NestedEnumtask_labelFilter<$PrismaModel>
  }

  export type NestedEnumtask_priorityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.task_priority | Enumtask_priorityFieldRefInput<$PrismaModel>
    in?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    notIn?: $Enums.task_priority[] | ListEnumtask_priorityFieldRefInput<$PrismaModel>
    not?: NestedEnumtask_priorityWithAggregatesFilter<$PrismaModel> | $Enums.task_priority
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumtask_priorityFilter<$PrismaModel>
    _max?: NestedEnumtask_priorityFilter<$PrismaModel>
  }
  export type NestedJsonFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type usersCreateWithoutProfileInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutProfileInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutProfileInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutProfileInput, usersUncheckedCreateWithoutProfileInput>
  }

  export type usersUpsertWithoutProfileInput = {
    update: XOR<usersUpdateWithoutProfileInput, usersUncheckedUpdateWithoutProfileInput>
    create: XOR<usersCreateWithoutProfileInput, usersUncheckedCreateWithoutProfileInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutProfileInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutProfileInput, usersUncheckedUpdateWithoutProfileInput>
  }

  export type usersUpdateWithoutProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type eventsCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    locations?: locationsCreateNestedManyWithoutEventInput
    sessions?: sessionsCreateNestedManyWithoutEventInput
  }

  export type eventsUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    locations?: locationsUncheckedCreateNestedManyWithoutEventInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutEventInput
  }

  export type eventsCreateOrConnectWithoutUsersInput = {
    where: eventsWhereUniqueInput
    create: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput>
  }

  export type eventsCreateManyUsersInputEnvelope = {
    data: eventsCreateManyUsersInput | eventsCreateManyUsersInput[]
    skipDuplicates?: boolean
  }

  export type incident_logsCreateWithoutUserInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutUserInput = {
    id?: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutUserInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput>
  }

  export type incident_logsCreateManyUserInputEnvelope = {
    data: incident_logsCreateManyUserInput | incident_logsCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type panic_button_logsCreateWithoutUsersInput = {
    id?: string
    timestamp?: Date | string
    incidents: incident_logsCreateNestedOneWithoutPanic_button_logsInput
    officers?: officersCreateNestedOneWithoutPanic_button_logsInput
  }

  export type panic_button_logsUncheckedCreateWithoutUsersInput = {
    id?: string
    officer_id?: string | null
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type panic_button_logsCreateOrConnectWithoutUsersInput = {
    where: panic_button_logsWhereUniqueInput
    create: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput>
  }

  export type panic_button_logsCreateManyUsersInputEnvelope = {
    data: panic_button_logsCreateManyUsersInput | panic_button_logsCreateManyUsersInput[]
    skipDuplicates?: boolean
  }

  export type profilesCreateWithoutUsersInput = {
    id?: string
    avatar?: string | null
    username?: string | null
    first_name?: string | null
    last_name?: string | null
    bio?: string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: Date | string | null
    nik?: string | null
    birth_place?: string | null
  }

  export type profilesUncheckedCreateWithoutUsersInput = {
    id?: string
    avatar?: string | null
    username?: string | null
    first_name?: string | null
    last_name?: string | null
    bio?: string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: Date | string | null
    nik?: string | null
    birth_place?: string | null
  }

  export type profilesCreateOrConnectWithoutUsersInput = {
    where: profilesWhereUniqueInput
    create: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
  }

  export type sessionsCreateWithoutUserInput = {
    id?: string
    status?: $Enums.session_status
    created_at?: Date | string
    event: eventsCreateNestedOneWithoutSessionsInput
  }

  export type sessionsUncheckedCreateWithoutUserInput = {
    id?: string
    event_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type sessionsCreateOrConnectWithoutUserInput = {
    where: sessionsWhereUniqueInput
    create: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput>
  }

  export type sessionsCreateManyUserInputEnvelope = {
    data: sessionsCreateManyUserInput | sessionsCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type timelinesCreateWithoutUserInput = {
    id?: string
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_incidents?: crime_incidentsCreateNestedOneWithoutTimelinesInput
    incident?: incident_logsCreateNestedOneWithoutTimelinesInput
  }

  export type timelinesUncheckedCreateWithoutUserInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type timelinesCreateOrConnectWithoutUserInput = {
    where: timelinesWhereUniqueInput
    create: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput>
  }

  export type timelinesCreateManyUserInputEnvelope = {
    data: timelinesCreateManyUserInput | timelinesCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type rolesCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersCreateNestedManyWithoutRolesInput
    permissions?: permissionsCreateNestedManyWithoutRoleInput
  }

  export type rolesUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersUncheckedCreateNestedManyWithoutRolesInput
    permissions?: permissionsUncheckedCreateNestedManyWithoutRoleInput
  }

  export type rolesCreateOrConnectWithoutUsersInput = {
    where: rolesWhereUniqueInput
    create: XOR<rolesCreateWithoutUsersInput, rolesUncheckedCreateWithoutUsersInput>
  }

  export type taskCreateWithoutUserInput = {
    id?: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type taskUncheckedCreateWithoutUserInput = {
    id?: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type taskCreateOrConnectWithoutUserInput = {
    where: taskWhereUniqueInput
    create: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput>
  }

  export type taskCreateManyUserInputEnvelope = {
    data: taskCreateManyUserInput | taskCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type messagesCreateWithoutSender_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_officer?: officersCreateNestedOneWithoutSentMessagesInput
    recipient_user?: usersCreateNestedOneWithoutReceivedMessagesInput
    recipient_officer?: officersCreateNestedOneWithoutReceivedMessagesInput
    inbox?: inboxCreateNestedOneWithoutMessagesInput
  }

  export type messagesUncheckedCreateWithoutSender_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateOrConnectWithoutSender_userInput = {
    where: messagesWhereUniqueInput
    create: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput>
  }

  export type messagesCreateManySender_userInputEnvelope = {
    data: messagesCreateManySender_userInput | messagesCreateManySender_userInput[]
    skipDuplicates?: boolean
  }

  export type messagesCreateWithoutRecipient_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_user?: usersCreateNestedOneWithoutSentMessagesInput
    sender_officer?: officersCreateNestedOneWithoutSentMessagesInput
    recipient_officer?: officersCreateNestedOneWithoutReceivedMessagesInput
    inbox?: inboxCreateNestedOneWithoutMessagesInput
  }

  export type messagesUncheckedCreateWithoutRecipient_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateOrConnectWithoutRecipient_userInput = {
    where: messagesWhereUniqueInput
    create: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput>
  }

  export type messagesCreateManyRecipient_userInputEnvelope = {
    data: messagesCreateManyRecipient_userInput | messagesCreateManyRecipient_userInput[]
    skipDuplicates?: boolean
  }

  export type projectsCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    datasets?: datasetsCreateNestedManyWithoutProjectsInput
    analyses?: analysesCreateNestedManyWithoutProjectsInput
  }

  export type projectsUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    datasets?: datasetsUncheckedCreateNestedManyWithoutProjectsInput
    analyses?: analysesUncheckedCreateNestedManyWithoutProjectsInput
  }

  export type projectsCreateOrConnectWithoutUsersInput = {
    where: projectsWhereUniqueInput
    create: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput>
  }

  export type projectsCreateManyUsersInputEnvelope = {
    data: projectsCreateManyUsersInput | projectsCreateManyUsersInput[]
    skipDuplicates?: boolean
  }

  export type inboxCreateWithoutUserInput = {
    id?: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    officer: officersCreateNestedOneWithoutInboxInput
    messages?: messagesCreateNestedManyWithoutInboxInput
  }

  export type inboxUncheckedCreateWithoutUserInput = {
    id?: string
    officer_id: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    messages?: messagesUncheckedCreateNestedManyWithoutInboxInput
  }

  export type inboxCreateOrConnectWithoutUserInput = {
    where: inboxWhereUniqueInput
    create: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
  }

  export type eventsUpsertWithWhereUniqueWithoutUsersInput = {
    where: eventsWhereUniqueInput
    update: XOR<eventsUpdateWithoutUsersInput, eventsUncheckedUpdateWithoutUsersInput>
    create: XOR<eventsCreateWithoutUsersInput, eventsUncheckedCreateWithoutUsersInput>
  }

  export type eventsUpdateWithWhereUniqueWithoutUsersInput = {
    where: eventsWhereUniqueInput
    data: XOR<eventsUpdateWithoutUsersInput, eventsUncheckedUpdateWithoutUsersInput>
  }

  export type eventsUpdateManyWithWhereWithoutUsersInput = {
    where: eventsScalarWhereInput
    data: XOR<eventsUpdateManyMutationInput, eventsUncheckedUpdateManyWithoutUsersInput>
  }

  export type eventsScalarWhereInput = {
    AND?: eventsScalarWhereInput | eventsScalarWhereInput[]
    OR?: eventsScalarWhereInput[]
    NOT?: eventsScalarWhereInput | eventsScalarWhereInput[]
    id?: UuidFilter<"events"> | string
    name?: StringFilter<"events"> | string
    description?: StringNullableFilter<"events"> | string | null
    code?: StringFilter<"events"> | string
    created_at?: DateTimeFilter<"events"> | Date | string
    user_id?: UuidFilter<"events"> | string
  }

  export type incident_logsUpsertWithWhereUniqueWithoutUserInput = {
    where: incident_logsWhereUniqueInput
    update: XOR<incident_logsUpdateWithoutUserInput, incident_logsUncheckedUpdateWithoutUserInput>
    create: XOR<incident_logsCreateWithoutUserInput, incident_logsUncheckedCreateWithoutUserInput>
  }

  export type incident_logsUpdateWithWhereUniqueWithoutUserInput = {
    where: incident_logsWhereUniqueInput
    data: XOR<incident_logsUpdateWithoutUserInput, incident_logsUncheckedUpdateWithoutUserInput>
  }

  export type incident_logsUpdateManyWithWhereWithoutUserInput = {
    where: incident_logsScalarWhereInput
    data: XOR<incident_logsUpdateManyMutationInput, incident_logsUncheckedUpdateManyWithoutUserInput>
  }

  export type incident_logsScalarWhereInput = {
    AND?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
    OR?: incident_logsScalarWhereInput[]
    NOT?: incident_logsScalarWhereInput | incident_logsScalarWhereInput[]
    id?: UuidFilter<"incident_logs"> | string
    user_id?: UuidFilter<"incident_logs"> | string
    location_id?: UuidFilter<"incident_logs"> | string
    category_id?: StringFilter<"incident_logs"> | string
    description?: StringNullableFilter<"incident_logs"> | string | null
    source?: StringNullableFilter<"incident_logs"> | string | null
    time?: DateTimeFilter<"incident_logs"> | Date | string
    verified?: BoolNullableFilter<"incident_logs"> | boolean | null
    severity?: StringNullableFilter<"incident_logs"> | string | null
    created_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"incident_logs"> | Date | string | null
  }

  export type panic_button_logsUpsertWithWhereUniqueWithoutUsersInput = {
    where: panic_button_logsWhereUniqueInput
    update: XOR<panic_button_logsUpdateWithoutUsersInput, panic_button_logsUncheckedUpdateWithoutUsersInput>
    create: XOR<panic_button_logsCreateWithoutUsersInput, panic_button_logsUncheckedCreateWithoutUsersInput>
  }

  export type panic_button_logsUpdateWithWhereUniqueWithoutUsersInput = {
    where: panic_button_logsWhereUniqueInput
    data: XOR<panic_button_logsUpdateWithoutUsersInput, panic_button_logsUncheckedUpdateWithoutUsersInput>
  }

  export type panic_button_logsUpdateManyWithWhereWithoutUsersInput = {
    where: panic_button_logsScalarWhereInput
    data: XOR<panic_button_logsUpdateManyMutationInput, panic_button_logsUncheckedUpdateManyWithoutUsersInput>
  }

  export type panic_button_logsScalarWhereInput = {
    AND?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
    OR?: panic_button_logsScalarWhereInput[]
    NOT?: panic_button_logsScalarWhereInput | panic_button_logsScalarWhereInput[]
    id?: UuidFilter<"panic_button_logs"> | string
    user_id?: UuidFilter<"panic_button_logs"> | string
    officer_id?: UuidNullableFilter<"panic_button_logs"> | string | null
    incident_logs_id?: UuidFilter<"panic_button_logs"> | string
    timestamp?: DateTimeFilter<"panic_button_logs"> | Date | string
  }

  export type profilesUpsertWithoutUsersInput = {
    update: XOR<profilesUpdateWithoutUsersInput, profilesUncheckedUpdateWithoutUsersInput>
    create: XOR<profilesCreateWithoutUsersInput, profilesUncheckedCreateWithoutUsersInput>
    where?: profilesWhereInput
  }

  export type profilesUpdateToOneWithWhereWithoutUsersInput = {
    where?: profilesWhereInput
    data: XOR<profilesUpdateWithoutUsersInput, profilesUncheckedUpdateWithoutUsersInput>
  }

  export type profilesUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type profilesUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    first_name?: NullableStringFieldUpdateOperationsInput | string | null
    last_name?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableJsonNullValueInput | InputJsonValue
    birth_date?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    nik?: NullableStringFieldUpdateOperationsInput | string | null
    birth_place?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type sessionsUpsertWithWhereUniqueWithoutUserInput = {
    where: sessionsWhereUniqueInput
    update: XOR<sessionsUpdateWithoutUserInput, sessionsUncheckedUpdateWithoutUserInput>
    create: XOR<sessionsCreateWithoutUserInput, sessionsUncheckedCreateWithoutUserInput>
  }

  export type sessionsUpdateWithWhereUniqueWithoutUserInput = {
    where: sessionsWhereUniqueInput
    data: XOR<sessionsUpdateWithoutUserInput, sessionsUncheckedUpdateWithoutUserInput>
  }

  export type sessionsUpdateManyWithWhereWithoutUserInput = {
    where: sessionsScalarWhereInput
    data: XOR<sessionsUpdateManyMutationInput, sessionsUncheckedUpdateManyWithoutUserInput>
  }

  export type sessionsScalarWhereInput = {
    AND?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
    OR?: sessionsScalarWhereInput[]
    NOT?: sessionsScalarWhereInput | sessionsScalarWhereInput[]
    id?: UuidFilter<"sessions"> | string
    user_id?: UuidFilter<"sessions"> | string
    event_id?: UuidFilter<"sessions"> | string
    status?: Enumsession_statusFilter<"sessions"> | $Enums.session_status
    created_at?: DateTimeFilter<"sessions"> | Date | string
  }

  export type timelinesUpsertWithWhereUniqueWithoutUserInput = {
    where: timelinesWhereUniqueInput
    update: XOR<timelinesUpdateWithoutUserInput, timelinesUncheckedUpdateWithoutUserInput>
    create: XOR<timelinesCreateWithoutUserInput, timelinesUncheckedCreateWithoutUserInput>
  }

  export type timelinesUpdateWithWhereUniqueWithoutUserInput = {
    where: timelinesWhereUniqueInput
    data: XOR<timelinesUpdateWithoutUserInput, timelinesUncheckedUpdateWithoutUserInput>
  }

  export type timelinesUpdateManyWithWhereWithoutUserInput = {
    where: timelinesScalarWhereInput
    data: XOR<timelinesUpdateManyMutationInput, timelinesUncheckedUpdateManyWithoutUserInput>
  }

  export type timelinesScalarWhereInput = {
    AND?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
    OR?: timelinesScalarWhereInput[]
    NOT?: timelinesScalarWhereInput | timelinesScalarWhereInput[]
    id?: UuidFilter<"timelines"> | string
    incident_logs_id?: UuidNullableFilter<"timelines"> | string | null
    crime_incidents_id?: StringNullableFilter<"timelines"> | string | null
    user_id?: UuidNullableFilter<"timelines"> | string | null
    title?: StringNullableFilter<"timelines"> | string | null
    description?: StringNullableFilter<"timelines"> | string | null
    timestamp?: DateTimeFilter<"timelines"> | Date | string
    created_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"timelines"> | Date | string | null
  }

  export type rolesUpsertWithoutUsersInput = {
    update: XOR<rolesUpdateWithoutUsersInput, rolesUncheckedUpdateWithoutUsersInput>
    create: XOR<rolesCreateWithoutUsersInput, rolesUncheckedCreateWithoutUsersInput>
    where?: rolesWhereInput
  }

  export type rolesUpdateToOneWithWhereWithoutUsersInput = {
    where?: rolesWhereInput
    data: XOR<rolesUpdateWithoutUsersInput, rolesUncheckedUpdateWithoutUsersInput>
  }

  export type rolesUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUpdateManyWithoutRolesNestedInput
    permissions?: permissionsUpdateManyWithoutRoleNestedInput
  }

  export type rolesUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUncheckedUpdateManyWithoutRolesNestedInput
    permissions?: permissionsUncheckedUpdateManyWithoutRoleNestedInput
  }

  export type taskUpsertWithWhereUniqueWithoutUserInput = {
    where: taskWhereUniqueInput
    update: XOR<taskUpdateWithoutUserInput, taskUncheckedUpdateWithoutUserInput>
    create: XOR<taskCreateWithoutUserInput, taskUncheckedCreateWithoutUserInput>
  }

  export type taskUpdateWithWhereUniqueWithoutUserInput = {
    where: taskWhereUniqueInput
    data: XOR<taskUpdateWithoutUserInput, taskUncheckedUpdateWithoutUserInput>
  }

  export type taskUpdateManyWithWhereWithoutUserInput = {
    where: taskScalarWhereInput
    data: XOR<taskUpdateManyMutationInput, taskUncheckedUpdateManyWithoutUserInput>
  }

  export type taskScalarWhereInput = {
    AND?: taskScalarWhereInput | taskScalarWhereInput[]
    OR?: taskScalarWhereInput[]
    NOT?: taskScalarWhereInput | taskScalarWhereInput[]
    id?: UuidFilter<"task"> | string
    user_id?: UuidFilter<"task"> | string
    code?: StringFilter<"task"> | string
    title?: StringNullableFilter<"task"> | string | null
    status?: Enumtask_statusFilter<"task"> | $Enums.task_status
    label?: Enumtask_labelFilter<"task"> | $Enums.task_label
    priority?: Enumtask_priorityFilter<"task"> | $Enums.task_priority
    estimated_hours?: FloatFilter<"task"> | number
    archived?: BoolFilter<"task"> | boolean
    created_at?: DateTimeFilter<"task"> | Date | string
    updated_at?: DateTimeFilter<"task"> | Date | string
  }

  export type messagesUpsertWithWhereUniqueWithoutSender_userInput = {
    where: messagesWhereUniqueInput
    update: XOR<messagesUpdateWithoutSender_userInput, messagesUncheckedUpdateWithoutSender_userInput>
    create: XOR<messagesCreateWithoutSender_userInput, messagesUncheckedCreateWithoutSender_userInput>
  }

  export type messagesUpdateWithWhereUniqueWithoutSender_userInput = {
    where: messagesWhereUniqueInput
    data: XOR<messagesUpdateWithoutSender_userInput, messagesUncheckedUpdateWithoutSender_userInput>
  }

  export type messagesUpdateManyWithWhereWithoutSender_userInput = {
    where: messagesScalarWhereInput
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyWithoutSender_userInput>
  }

  export type messagesScalarWhereInput = {
    AND?: messagesScalarWhereInput | messagesScalarWhereInput[]
    OR?: messagesScalarWhereInput[]
    NOT?: messagesScalarWhereInput | messagesScalarWhereInput[]
    id?: UuidFilter<"messages"> | string
    subject?: StringFilter<"messages"> | string
    content?: StringFilter<"messages"> | string
    message_type?: StringNullableFilter<"messages"> | string | null
    message_type_label?: StringNullableFilter<"messages"> | string | null
    sender_user_id?: UuidNullableFilter<"messages"> | string | null
    sender_officer_id?: UuidNullableFilter<"messages"> | string | null
    recipient_user_id?: UuidNullableFilter<"messages"> | string | null
    recipient_officer_id?: UuidNullableFilter<"messages"> | string | null
    inbox_id?: UuidNullableFilter<"messages"> | string | null
    status?: Enumstatus_messagesFilter<"messages"> | $Enums.status_messages
    created_at?: DateTimeFilter<"messages"> | Date | string
    updated_at?: DateTimeFilter<"messages"> | Date | string
    file_url?: StringNullableFilter<"messages"> | string | null
    file_type?: StringNullableFilter<"messages"> | string | null
    file_name?: StringNullableFilter<"messages"> | string | null
    is_starred?: BoolFilter<"messages"> | boolean
  }

  export type messagesUpsertWithWhereUniqueWithoutRecipient_userInput = {
    where: messagesWhereUniqueInput
    update: XOR<messagesUpdateWithoutRecipient_userInput, messagesUncheckedUpdateWithoutRecipient_userInput>
    create: XOR<messagesCreateWithoutRecipient_userInput, messagesUncheckedCreateWithoutRecipient_userInput>
  }

  export type messagesUpdateWithWhereUniqueWithoutRecipient_userInput = {
    where: messagesWhereUniqueInput
    data: XOR<messagesUpdateWithoutRecipient_userInput, messagesUncheckedUpdateWithoutRecipient_userInput>
  }

  export type messagesUpdateManyWithWhereWithoutRecipient_userInput = {
    where: messagesScalarWhereInput
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyWithoutRecipient_userInput>
  }

  export type projectsUpsertWithWhereUniqueWithoutUsersInput = {
    where: projectsWhereUniqueInput
    update: XOR<projectsUpdateWithoutUsersInput, projectsUncheckedUpdateWithoutUsersInput>
    create: XOR<projectsCreateWithoutUsersInput, projectsUncheckedCreateWithoutUsersInput>
  }

  export type projectsUpdateWithWhereUniqueWithoutUsersInput = {
    where: projectsWhereUniqueInput
    data: XOR<projectsUpdateWithoutUsersInput, projectsUncheckedUpdateWithoutUsersInput>
  }

  export type projectsUpdateManyWithWhereWithoutUsersInput = {
    where: projectsScalarWhereInput
    data: XOR<projectsUpdateManyMutationInput, projectsUncheckedUpdateManyWithoutUsersInput>
  }

  export type projectsScalarWhereInput = {
    AND?: projectsScalarWhereInput | projectsScalarWhereInput[]
    OR?: projectsScalarWhereInput[]
    NOT?: projectsScalarWhereInput | projectsScalarWhereInput[]
    id?: UuidFilter<"projects"> | string
    name?: StringFilter<"projects"> | string
    description?: StringNullableFilter<"projects"> | string | null
    user_id?: UuidFilter<"projects"> | string
    created_at?: DateTimeFilter<"projects"> | Date | string
    updated_at?: DateTimeFilter<"projects"> | Date | string
  }

  export type inboxUpsertWithoutUserInput = {
    update: XOR<inboxUpdateWithoutUserInput, inboxUncheckedUpdateWithoutUserInput>
    create: XOR<inboxCreateWithoutUserInput, inboxUncheckedCreateWithoutUserInput>
    where?: inboxWhereInput
  }

  export type inboxUpdateToOneWithWhereWithoutUserInput = {
    where?: inboxWhereInput
    data: XOR<inboxUpdateWithoutUserInput, inboxUncheckedUpdateWithoutUserInput>
  }

  export type inboxUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officer?: officersUpdateOneRequiredWithoutInboxNestedInput
    messages?: messagesUpdateManyWithoutInboxNestedInput
  }

  export type inboxUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    officer_id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    messages?: messagesUncheckedUpdateManyWithoutInboxNestedInput
  }

  export type officersCreateWithoutRolesInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutRolesInput = {
    unit_id?: string | null
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutRolesInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput>
  }

  export type officersCreateManyRolesInputEnvelope = {
    data: officersCreateManyRolesInput | officersCreateManyRolesInput[]
    skipDuplicates?: boolean
  }

  export type permissionsCreateWithoutRoleInput = {
    id?: string
    action: string
    created_at?: Date | string
    updated_at?: Date | string
    resource: resourcesCreateNestedOneWithoutPermissionsInput
  }

  export type permissionsUncheckedCreateWithoutRoleInput = {
    id?: string
    action: string
    resource_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type permissionsCreateOrConnectWithoutRoleInput = {
    where: permissionsWhereUniqueInput
    create: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput>
  }

  export type permissionsCreateManyRoleInputEnvelope = {
    data: permissionsCreateManyRoleInput | permissionsCreateManyRoleInput[]
    skipDuplicates?: boolean
  }

  export type usersCreateWithoutRoleInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutRoleInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutRoleInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput>
  }

  export type usersCreateManyRoleInputEnvelope = {
    data: usersCreateManyRoleInput | usersCreateManyRoleInput[]
    skipDuplicates?: boolean
  }

  export type officersUpsertWithWhereUniqueWithoutRolesInput = {
    where: officersWhereUniqueInput
    update: XOR<officersUpdateWithoutRolesInput, officersUncheckedUpdateWithoutRolesInput>
    create: XOR<officersCreateWithoutRolesInput, officersUncheckedCreateWithoutRolesInput>
  }

  export type officersUpdateWithWhereUniqueWithoutRolesInput = {
    where: officersWhereUniqueInput
    data: XOR<officersUpdateWithoutRolesInput, officersUncheckedUpdateWithoutRolesInput>
  }

  export type officersUpdateManyWithWhereWithoutRolesInput = {
    where: officersScalarWhereInput
    data: XOR<officersUpdateManyMutationInput, officersUncheckedUpdateManyWithoutRolesInput>
  }

  export type officersScalarWhereInput = {
    AND?: officersScalarWhereInput | officersScalarWhereInput[]
    OR?: officersScalarWhereInput[]
    NOT?: officersScalarWhereInput | officersScalarWhereInput[]
    unit_id?: StringNullableFilter<"officers"> | string | null
    role_id?: UuidFilter<"officers"> | string
    nrp?: StringNullableFilter<"officers"> | string | null
    name?: StringFilter<"officers"> | string
    rank?: StringNullableFilter<"officers"> | string | null
    position?: StringNullableFilter<"officers"> | string | null
    phone?: StringNullableFilter<"officers"> | string | null
    email?: StringNullableFilter<"officers"> | string | null
    avatar?: StringNullableFilter<"officers"> | string | null
    valid_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    qr_code?: StringNullableFilter<"officers"> | string | null
    created_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"officers"> | Date | string | null
    patrol_unit_id?: StringNullableFilter<"officers"> | string | null
    id?: UuidFilter<"officers"> | string
    banned_reason?: StringNullableFilter<"officers"> | string | null
    banned_until?: DateTimeNullableFilter<"officers"> | Date | string | null
    is_banned?: BoolFilter<"officers"> | boolean
    panic_strike?: IntFilter<"officers"> | number
    spoofing_attempts?: IntFilter<"officers"> | number
    place_of_birth?: StringNullableFilter<"officers"> | string | null
    date_of_birth?: DateTimeNullableFilter<"officers"> | Date | string | null
  }

  export type permissionsUpsertWithWhereUniqueWithoutRoleInput = {
    where: permissionsWhereUniqueInput
    update: XOR<permissionsUpdateWithoutRoleInput, permissionsUncheckedUpdateWithoutRoleInput>
    create: XOR<permissionsCreateWithoutRoleInput, permissionsUncheckedCreateWithoutRoleInput>
  }

  export type permissionsUpdateWithWhereUniqueWithoutRoleInput = {
    where: permissionsWhereUniqueInput
    data: XOR<permissionsUpdateWithoutRoleInput, permissionsUncheckedUpdateWithoutRoleInput>
  }

  export type permissionsUpdateManyWithWhereWithoutRoleInput = {
    where: permissionsScalarWhereInput
    data: XOR<permissionsUpdateManyMutationInput, permissionsUncheckedUpdateManyWithoutRoleInput>
  }

  export type permissionsScalarWhereInput = {
    AND?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
    OR?: permissionsScalarWhereInput[]
    NOT?: permissionsScalarWhereInput | permissionsScalarWhereInput[]
    id?: UuidFilter<"permissions"> | string
    action?: StringFilter<"permissions"> | string
    resource_id?: UuidFilter<"permissions"> | string
    role_id?: UuidFilter<"permissions"> | string
    created_at?: DateTimeFilter<"permissions"> | Date | string
    updated_at?: DateTimeFilter<"permissions"> | Date | string
  }

  export type usersUpsertWithWhereUniqueWithoutRoleInput = {
    where: usersWhereUniqueInput
    update: XOR<usersUpdateWithoutRoleInput, usersUncheckedUpdateWithoutRoleInput>
    create: XOR<usersCreateWithoutRoleInput, usersUncheckedCreateWithoutRoleInput>
  }

  export type usersUpdateWithWhereUniqueWithoutRoleInput = {
    where: usersWhereUniqueInput
    data: XOR<usersUpdateWithoutRoleInput, usersUncheckedUpdateWithoutRoleInput>
  }

  export type usersUpdateManyWithWhereWithoutRoleInput = {
    where: usersScalarWhereInput
    data: XOR<usersUpdateManyMutationInput, usersUncheckedUpdateManyWithoutRoleInput>
  }

  export type usersScalarWhereInput = {
    AND?: usersScalarWhereInput | usersScalarWhereInput[]
    OR?: usersScalarWhereInput[]
    NOT?: usersScalarWhereInput | usersScalarWhereInput[]
    id?: UuidFilter<"users"> | string
    roles_id?: UuidFilter<"users"> | string
    email?: StringFilter<"users"> | string
    phone?: StringNullableFilter<"users"> | string | null
    encrypted_password?: StringNullableFilter<"users"> | string | null
    invited_at?: DateTimeNullableFilter<"users"> | Date | string | null
    confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    email_confirmed_at?: DateTimeNullableFilter<"users"> | Date | string | null
    recovery_sent_at?: DateTimeNullableFilter<"users"> | Date | string | null
    last_sign_in_at?: DateTimeNullableFilter<"users"> | Date | string | null
    app_metadata?: JsonNullableFilter<"users">
    user_metadata?: JsonNullableFilter<"users">
    created_at?: DateTimeFilter<"users"> | Date | string
    updated_at?: DateTimeFilter<"users"> | Date | string
    banned_until?: DateTimeNullableFilter<"users"> | Date | string | null
    is_anonymous?: BoolFilter<"users"> | boolean
    banned_reason?: StringNullableFilter<"users"> | string | null
    is_banned?: BoolFilter<"users"> | boolean
    panic_strike?: IntFilter<"users"> | number
    spoofing_attempts?: IntFilter<"users"> | number
  }

  export type eventsCreateWithoutSessionsInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    users: usersCreateNestedOneWithoutEventsInput
    locations?: locationsCreateNestedManyWithoutEventInput
  }

  export type eventsUncheckedCreateWithoutSessionsInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    user_id: string
    locations?: locationsUncheckedCreateNestedManyWithoutEventInput
  }

  export type eventsCreateOrConnectWithoutSessionsInput = {
    where: eventsWhereUniqueInput
    create: XOR<eventsCreateWithoutSessionsInput, eventsUncheckedCreateWithoutSessionsInput>
  }

  export type usersCreateWithoutSessionsInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutSessionsInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutSessionsInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutSessionsInput, usersUncheckedCreateWithoutSessionsInput>
  }

  export type eventsUpsertWithoutSessionsInput = {
    update: XOR<eventsUpdateWithoutSessionsInput, eventsUncheckedUpdateWithoutSessionsInput>
    create: XOR<eventsCreateWithoutSessionsInput, eventsUncheckedCreateWithoutSessionsInput>
    where?: eventsWhereInput
  }

  export type eventsUpdateToOneWithWhereWithoutSessionsInput = {
    where?: eventsWhereInput
    data: XOR<eventsUpdateWithoutSessionsInput, eventsUncheckedUpdateWithoutSessionsInput>
  }

  export type eventsUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutEventsNestedInput
    locations?: locationsUpdateManyWithoutEventNestedInput
  }

  export type eventsUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user_id?: StringFieldUpdateOperationsInput | string
    locations?: locationsUncheckedUpdateManyWithoutEventNestedInput
  }

  export type usersUpsertWithoutSessionsInput = {
    update: XOR<usersUpdateWithoutSessionsInput, usersUncheckedUpdateWithoutSessionsInput>
    create: XOR<usersCreateWithoutSessionsInput, usersUncheckedCreateWithoutSessionsInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutSessionsInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutSessionsInput, usersUncheckedUpdateWithoutSessionsInput>
  }

  export type usersUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type usersCreateWithoutEventsInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutEventsInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutEventsInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutEventsInput, usersUncheckedCreateWithoutEventsInput>
  }

  export type sessionsCreateWithoutEventInput = {
    id?: string
    status?: $Enums.session_status
    created_at?: Date | string
    user: usersCreateNestedOneWithoutSessionsInput
  }

  export type sessionsUncheckedCreateWithoutEventInput = {
    id?: string
    user_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type sessionsCreateOrConnectWithoutEventInput = {
    where: sessionsWhereUniqueInput
    create: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput>
  }

  export type sessionsCreateManyEventInputEnvelope = {
    data: sessionsCreateManyEventInput | sessionsCreateManyEventInput[]
    skipDuplicates?: boolean
  }

  export type usersUpsertWithoutEventsInput = {
    update: XOR<usersUpdateWithoutEventsInput, usersUncheckedUpdateWithoutEventsInput>
    create: XOR<usersCreateWithoutEventsInput, usersUncheckedCreateWithoutEventsInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutEventsInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutEventsInput, usersUncheckedUpdateWithoutEventsInput>
  }

  export type usersUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type locationsUpdateWithWhereUniqueWithoutEventInput = {
    where: locationsWhereUniqueInput
    data: XOR<locationsUpdateWithoutEventInput, locationsUncheckedUpdateWithoutEventInput>
  }

  export type locationsUpdateManyWithWhereWithoutEventInput = {
    where: locationsScalarWhereInput
    data: XOR<locationsUpdateManyMutationInput, locationsUncheckedUpdateManyWithoutEventInput>
  }

  export type locationsScalarWhereInput = {
    AND?: locationsScalarWhereInput | locationsScalarWhereInput[]
    OR?: locationsScalarWhereInput[]
    NOT?: locationsScalarWhereInput | locationsScalarWhereInput[]
    id?: UuidFilter<"locations"> | string
    district_id?: StringFilter<"locations"> | string
    event_id?: UuidFilter<"locations"> | string
    address?: StringNullableFilter<"locations"> | string | null
    type?: StringNullableFilter<"locations"> | string | null
    latitude?: FloatFilter<"locations"> | number
    longitude?: FloatFilter<"locations"> | number
    land_area?: FloatNullableFilter<"locations"> | number | null
    created_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"locations"> | Date | string | null
    distance_to_unit?: FloatNullableFilter<"locations"> | number | null
  }

  export type sessionsUpsertWithWhereUniqueWithoutEventInput = {
    where: sessionsWhereUniqueInput
    update: XOR<sessionsUpdateWithoutEventInput, sessionsUncheckedUpdateWithoutEventInput>
    create: XOR<sessionsCreateWithoutEventInput, sessionsUncheckedCreateWithoutEventInput>
  }

  export type sessionsUpdateWithWhereUniqueWithoutEventInput = {
    where: sessionsWhereUniqueInput
    data: XOR<sessionsUpdateWithoutEventInput, sessionsUncheckedUpdateWithoutEventInput>
  }

  export type sessionsUpdateManyWithWhereWithoutEventInput = {
    where: sessionsScalarWhereInput
    data: XOR<sessionsUpdateManyMutationInput, sessionsUncheckedUpdateManyWithoutEventInput>
  }

  export type permissionsCreateWithoutResourceInput = {
    id?: string
    action: string
    created_at?: Date | string
    updated_at?: Date | string
    role: rolesCreateNestedOneWithoutPermissionsInput
  }

  export type permissionsUncheckedCreateWithoutResourceInput = {
    id?: string
    action: string
    role_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type permissionsCreateOrConnectWithoutResourceInput = {
    where: permissionsWhereUniqueInput
    create: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput>
  }

  export type permissionsCreateManyResourceInputEnvelope = {
    data: permissionsCreateManyResourceInput | permissionsCreateManyResourceInput[]
    skipDuplicates?: boolean
  }

  export type permissionsUpsertWithWhereUniqueWithoutResourceInput = {
    where: permissionsWhereUniqueInput
    update: XOR<permissionsUpdateWithoutResourceInput, permissionsUncheckedUpdateWithoutResourceInput>
    create: XOR<permissionsCreateWithoutResourceInput, permissionsUncheckedCreateWithoutResourceInput>
  }

  export type permissionsUpdateWithWhereUniqueWithoutResourceInput = {
    where: permissionsWhereUniqueInput
    data: XOR<permissionsUpdateWithoutResourceInput, permissionsUncheckedUpdateWithoutResourceInput>
  }

  export type permissionsUpdateManyWithWhereWithoutResourceInput = {
    where: permissionsScalarWhereInput
    data: XOR<permissionsUpdateManyMutationInput, permissionsUncheckedUpdateManyWithoutResourceInput>
  }

  export type resourcesCreateWithoutPermissionsInput = {
    id?: string
    name: string
    type?: string | null
    description?: string | null
    instance_role?: string | null
    relations?: string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type resourcesUncheckedCreateWithoutPermissionsInput = {
    id?: string
    name: string
    type?: string | null
    description?: string | null
    instance_role?: string | null
    relations?: string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type resourcesCreateOrConnectWithoutPermissionsInput = {
    where: resourcesWhereUniqueInput
    create: XOR<resourcesCreateWithoutPermissionsInput, resourcesUncheckedCreateWithoutPermissionsInput>
  }

  export type rolesCreateWithoutPermissionsInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersCreateNestedManyWithoutRolesInput
    users?: usersCreateNestedManyWithoutRoleInput
  }

  export type rolesUncheckedCreateWithoutPermissionsInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    officers?: officersUncheckedCreateNestedManyWithoutRolesInput
    users?: usersUncheckedCreateNestedManyWithoutRoleInput
  }

  export type rolesCreateOrConnectWithoutPermissionsInput = {
    where: rolesWhereUniqueInput
    create: XOR<rolesCreateWithoutPermissionsInput, rolesUncheckedCreateWithoutPermissionsInput>
  }

  export type resourcesUpsertWithoutPermissionsInput = {
    update: XOR<resourcesUpdateWithoutPermissionsInput, resourcesUncheckedUpdateWithoutPermissionsInput>
    create: XOR<resourcesCreateWithoutPermissionsInput, resourcesUncheckedCreateWithoutPermissionsInput>
    where?: resourcesWhereInput
  }

  export type resourcesUpdateToOneWithWhereWithoutPermissionsInput = {
    where?: resourcesWhereInput
    data: XOR<resourcesUpdateWithoutPermissionsInput, resourcesUncheckedUpdateWithoutPermissionsInput>
  }

  export type resourcesUpdateWithoutPermissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type resourcesUncheckedUpdateWithoutPermissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    instance_role?: NullableStringFieldUpdateOperationsInput | string | null
    relations?: NullableStringFieldUpdateOperationsInput | string | null
    attributes?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type rolesUpsertWithoutPermissionsInput = {
    update: XOR<rolesUpdateWithoutPermissionsInput, rolesUncheckedUpdateWithoutPermissionsInput>
    create: XOR<rolesCreateWithoutPermissionsInput, rolesUncheckedCreateWithoutPermissionsInput>
    where?: rolesWhereInput
  }

  export type rolesUpdateToOneWithWhereWithoutPermissionsInput = {
    where?: rolesWhereInput
    data: XOR<rolesUpdateWithoutPermissionsInput, rolesUncheckedUpdateWithoutPermissionsInput>
  }

  export type rolesUpdateWithoutPermissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUpdateManyWithoutRolesNestedInput
    users?: usersUpdateManyWithoutRoleNestedInput
  }

  export type rolesUncheckedUpdateWithoutPermissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUncheckedUpdateManyWithoutRolesNestedInput
    users?: usersUncheckedUpdateManyWithoutRoleNestedInput
  }

  export type districtsCreateWithoutCitiesInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutCitiesInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutCitiesInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput>
  }

  export type districtsCreateManyCitiesInputEnvelope = {
    data: districtsCreateManyCitiesInput | districtsCreateManyCitiesInput[]
    skipDuplicates?: boolean
  }

  export type districtsUpsertWithWhereUniqueWithoutCitiesInput = {
    where: districtsWhereUniqueInput
    update: XOR<districtsUpdateWithoutCitiesInput, districtsUncheckedUpdateWithoutCitiesInput>
    create: XOR<districtsCreateWithoutCitiesInput, districtsUncheckedCreateWithoutCitiesInput>
  }

  export type districtsUpdateWithWhereUniqueWithoutCitiesInput = {
    where: districtsWhereUniqueInput
    data: XOR<districtsUpdateWithoutCitiesInput, districtsUncheckedUpdateWithoutCitiesInput>
  }

  export type districtsUpdateManyWithWhereWithoutCitiesInput = {
    where: districtsScalarWhereInput
    data: XOR<districtsUpdateManyMutationInput, districtsUncheckedUpdateManyWithoutCitiesInput>
  }

  export type districtsScalarWhereInput = {
    AND?: districtsScalarWhereInput | districtsScalarWhereInput[]
    OR?: districtsScalarWhereInput[]
    NOT?: districtsScalarWhereInput | districtsScalarWhereInput[]
    id?: StringFilter<"districts"> | string
    city_id?: StringFilter<"districts"> | string
    name?: StringFilter<"districts"> | string
    created_at?: DateTimeNullableFilter<"districts"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"districts"> | Date | string | null
  }

  export type unitsUpdateWithWhereUniqueWithoutCitiesInput = {
    where: unitsWhereUniqueInput
    data: XOR<unitsUpdateWithoutCitiesInput, unitsUncheckedUpdateWithoutCitiesInput>
  }

  export type unitsUpdateManyWithWhereWithoutCitiesInput = {
    where: unitsScalarWhereInput
    data: XOR<unitsUpdateManyMutationInput, unitsUncheckedUpdateManyWithoutCitiesInput>
  }

  export type unitsScalarWhereInput = {
    AND?: unitsScalarWhereInput | unitsScalarWhereInput[]
    OR?: unitsScalarWhereInput[]
    NOT?: unitsScalarWhereInput | unitsScalarWhereInput[]
    code_unit?: StringFilter<"units"> | string
    district_id?: StringNullableFilter<"units"> | string | null
    name?: StringFilter<"units"> | string
    description?: StringNullableFilter<"units"> | string | null
    type?: Enumunit_typeFilter<"units"> | $Enums.unit_type
    created_at?: DateTimeNullableFilter<"units"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"units"> | Date | string | null
    address?: StringNullableFilter<"units"> | string | null
    land_area?: FloatNullableFilter<"units"> | number | null
    latitude?: FloatFilter<"units"> | number
    longitude?: FloatFilter<"units"> | number
    city_id?: StringFilter<"units"> | string
    phone?: StringNullableFilter<"units"> | string | null
  }

  export type crime_categoriesCreateWithoutCrime_incidentsInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    incident_logs?: incident_logsCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesUncheckedCreateWithoutCrime_incidentsInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesCreateOrConnectWithoutCrime_incidentsInput = {
    where: crime_categoriesWhereUniqueInput
    create: XOR<crime_categoriesCreateWithoutCrime_incidentsInput, crime_categoriesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type crimesCreateWithoutCrime_incidentsInput = {
    id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
    districts: districtsCreateNestedOneWithoutCrimesInput
  }

  export type crimesUncheckedCreateWithoutCrime_incidentsInput = {
    id: string
    district_id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
  }

  export type crimesCreateOrConnectWithoutCrime_incidentsInput = {
    where: crimesWhereUniqueInput
    create: XOR<crimesCreateWithoutCrime_incidentsInput, crimesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type evidenceCreateWithoutCrime_incidentsInput = {
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
    incident?: incident_logsCreateNestedOneWithoutEvidenceInput
  }

  export type evidenceUncheckedCreateWithoutCrime_incidentsInput = {
    incident_logs_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type evidenceCreateOrConnectWithoutCrime_incidentsInput = {
    where: evidenceWhereUniqueInput
    create: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type evidenceCreateManyCrime_incidentsInputEnvelope = {
    data: evidenceCreateManyCrime_incidentsInput | evidenceCreateManyCrime_incidentsInput[]
    skipDuplicates?: boolean
  }

  export type timelinesCreateWithoutCrime_incidentsInput = {
    id?: string
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    incident?: incident_logsCreateNestedOneWithoutTimelinesInput
    user?: usersCreateNestedOneWithoutTimelinesInput
  }

  export type timelinesUncheckedCreateWithoutCrime_incidentsInput = {
    id?: string
    incident_logs_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type timelinesCreateOrConnectWithoutCrime_incidentsInput = {
    where: timelinesWhereUniqueInput
    create: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type timelinesCreateManyCrime_incidentsInputEnvelope = {
    data: timelinesCreateManyCrime_incidentsInput | timelinesCreateManyCrime_incidentsInput[]
    skipDuplicates?: boolean
  }

  export type witnessesCreateWithoutCrime_incidentsInput = {
    id?: string
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    incident?: incident_logsCreateNestedOneWithoutWitnessesInput
  }

  export type witnessesUncheckedCreateWithoutCrime_incidentsInput = {
    id?: string
    incident_logs_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesCreateOrConnectWithoutCrime_incidentsInput = {
    where: witnessesWhereUniqueInput
    create: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type witnessesCreateManyCrime_incidentsInputEnvelope = {
    data: witnessesCreateManyCrime_incidentsInput | witnessesCreateManyCrime_incidentsInput[]
    skipDuplicates?: boolean
  }

  export type crime_categoriesUpsertWithoutCrime_incidentsInput = {
    update: XOR<crime_categoriesUpdateWithoutCrime_incidentsInput, crime_categoriesUncheckedUpdateWithoutCrime_incidentsInput>
    create: XOR<crime_categoriesCreateWithoutCrime_incidentsInput, crime_categoriesUncheckedCreateWithoutCrime_incidentsInput>
    where?: crime_categoriesWhereInput
  }

  export type crime_categoriesUpdateToOneWithWhereWithoutCrime_incidentsInput = {
    where?: crime_categoriesWhereInput
    data: XOR<crime_categoriesUpdateWithoutCrime_incidentsInput, crime_categoriesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type crime_categoriesUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs?: incident_logsUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type crime_categoriesUncheckedUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs?: incident_logsUncheckedUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type crimesUpsertWithoutCrime_incidentsInput = {
    update: XOR<crimesUpdateWithoutCrime_incidentsInput, crimesUncheckedUpdateWithoutCrime_incidentsInput>
    create: XOR<crimesCreateWithoutCrime_incidentsInput, crimesUncheckedCreateWithoutCrime_incidentsInput>
    where?: crimesWhereInput
  }

  export type crimesUpdateToOneWithWhereWithoutCrime_incidentsInput = {
    where?: crimesWhereInput
    data: XOR<crimesUpdateWithoutCrime_incidentsInput, crimesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type crimesUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
    districts?: districtsUpdateOneRequiredWithoutCrimesNestedInput
  }

  export type crimesUncheckedUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
  }

  export type locationsUpdateToOneWithWhereWithoutCrime_incidentsInput = {
    where?: locationsWhereInput
    data: XOR<locationsUpdateWithoutCrime_incidentsInput, locationsUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type locationsUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type evidenceUpsertWithWhereUniqueWithoutCrime_incidentsInput = {
    where: evidenceWhereUniqueInput
    update: XOR<evidenceUpdateWithoutCrime_incidentsInput, evidenceUncheckedUpdateWithoutCrime_incidentsInput>
    create: XOR<evidenceCreateWithoutCrime_incidentsInput, evidenceUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type evidenceUpdateWithWhereUniqueWithoutCrime_incidentsInput = {
    where: evidenceWhereUniqueInput
    data: XOR<evidenceUpdateWithoutCrime_incidentsInput, evidenceUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type evidenceUpdateManyWithWhereWithoutCrime_incidentsInput = {
    where: evidenceScalarWhereInput
    data: XOR<evidenceUpdateManyMutationInput, evidenceUncheckedUpdateManyWithoutCrime_incidentsInput>
  }

  export type evidenceScalarWhereInput = {
    AND?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
    OR?: evidenceScalarWhereInput[]
    NOT?: evidenceScalarWhereInput | evidenceScalarWhereInput[]
    incident_logs_id?: UuidNullableFilter<"evidence"> | string | null
    crime_incidents_id?: StringNullableFilter<"evidence"> | string | null
    type?: StringFilter<"evidence"> | string
    url?: StringFilter<"evidence"> | string
    status?: StringNullableFilter<"evidence"> | string | null
    uploaded_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"evidence"> | Date | string | null
    caption?: StringNullableFilter<"evidence"> | string | null
    description?: StringNullableFilter<"evidence"> | string | null
    metadata?: JsonNullableFilter<"evidence">
    id?: StringFilter<"evidence"> | string
  }

  export type timelinesUpsertWithWhereUniqueWithoutCrime_incidentsInput = {
    where: timelinesWhereUniqueInput
    update: XOR<timelinesUpdateWithoutCrime_incidentsInput, timelinesUncheckedUpdateWithoutCrime_incidentsInput>
    create: XOR<timelinesCreateWithoutCrime_incidentsInput, timelinesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type timelinesUpdateWithWhereUniqueWithoutCrime_incidentsInput = {
    where: timelinesWhereUniqueInput
    data: XOR<timelinesUpdateWithoutCrime_incidentsInput, timelinesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type timelinesUpdateManyWithWhereWithoutCrime_incidentsInput = {
    where: timelinesScalarWhereInput
    data: XOR<timelinesUpdateManyMutationInput, timelinesUncheckedUpdateManyWithoutCrime_incidentsInput>
  }

  export type witnessesUpsertWithWhereUniqueWithoutCrime_incidentsInput = {
    where: witnessesWhereUniqueInput
    update: XOR<witnessesUpdateWithoutCrime_incidentsInput, witnessesUncheckedUpdateWithoutCrime_incidentsInput>
    create: XOR<witnessesCreateWithoutCrime_incidentsInput, witnessesUncheckedCreateWithoutCrime_incidentsInput>
  }

  export type witnessesUpdateWithWhereUniqueWithoutCrime_incidentsInput = {
    where: witnessesWhereUniqueInput
    data: XOR<witnessesUpdateWithoutCrime_incidentsInput, witnessesUncheckedUpdateWithoutCrime_incidentsInput>
  }

  export type witnessesUpdateManyWithWhereWithoutCrime_incidentsInput = {
    where: witnessesScalarWhereInput
    data: XOR<witnessesUpdateManyMutationInput, witnessesUncheckedUpdateManyWithoutCrime_incidentsInput>
  }

  export type witnessesScalarWhereInput = {
    AND?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
    OR?: witnessesScalarWhereInput[]
    NOT?: witnessesScalarWhereInput | witnessesScalarWhereInput[]
    id?: UuidFilter<"witnesses"> | string
    incident_logs_id?: UuidNullableFilter<"witnesses"> | string | null
    crime_incidents_id?: StringNullableFilter<"witnesses"> | string | null
    name?: StringNullableFilter<"witnesses"> | string | null
    contact_info?: StringNullableFilter<"witnesses"> | string | null
    statement?: StringNullableFilter<"witnesses"> | string | null
    created_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"witnesses"> | Date | string | null
  }

  export type crime_incidentsCreateWithoutCrime_categoriesInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutCrime_categoriesInput = {
    id: string
    crime_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutCrime_categoriesInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput>
  }

  export type crime_incidentsCreateManyCrime_categoriesInputEnvelope = {
    data: crime_incidentsCreateManyCrime_categoriesInput | crime_incidentsCreateManyCrime_categoriesInput[]
    skipDuplicates?: boolean
  }

  export type incident_logsCreateWithoutCrime_categoriesInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutCrime_categoriesInput = {
    id?: string
    user_id: string
    location_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutCrime_categoriesInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput>
  }

  export type incident_logsCreateManyCrime_categoriesInputEnvelope = {
    data: incident_logsCreateManyCrime_categoriesInput | incident_logsCreateManyCrime_categoriesInput[]
    skipDuplicates?: boolean
  }

  export type crime_incidentsUpsertWithWhereUniqueWithoutCrime_categoriesInput = {
    where: crime_incidentsWhereUniqueInput
    update: XOR<crime_incidentsUpdateWithoutCrime_categoriesInput, crime_incidentsUncheckedUpdateWithoutCrime_categoriesInput>
    create: XOR<crime_incidentsCreateWithoutCrime_categoriesInput, crime_incidentsUncheckedCreateWithoutCrime_categoriesInput>
  }

  export type crime_incidentsUpdateWithWhereUniqueWithoutCrime_categoriesInput = {
    where: crime_incidentsWhereUniqueInput
    data: XOR<crime_incidentsUpdateWithoutCrime_categoriesInput, crime_incidentsUncheckedUpdateWithoutCrime_categoriesInput>
  }

  export type crime_incidentsUpdateManyWithWhereWithoutCrime_categoriesInput = {
    where: crime_incidentsScalarWhereInput
    data: XOR<crime_incidentsUpdateManyMutationInput, crime_incidentsUncheckedUpdateManyWithoutCrime_categoriesInput>
  }

  export type crime_incidentsScalarWhereInput = {
    AND?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
    OR?: crime_incidentsScalarWhereInput[]
    NOT?: crime_incidentsScalarWhereInput | crime_incidentsScalarWhereInput[]
    id?: StringFilter<"crime_incidents"> | string
    crime_id?: StringFilter<"crime_incidents"> | string
    crime_category_id?: StringFilter<"crime_incidents"> | string
    location_id?: UuidFilter<"crime_incidents"> | string
    description?: StringFilter<"crime_incidents"> | string
    victim_count?: IntFilter<"crime_incidents"> | number
    status?: Enumcrime_statusNullableFilter<"crime_incidents"> | $Enums.crime_status | null
    created_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"crime_incidents"> | Date | string | null
    timestamp?: DateTimeFilter<"crime_incidents"> | Date | string
  }

  export type incident_logsUpsertWithWhereUniqueWithoutCrime_categoriesInput = {
    where: incident_logsWhereUniqueInput
    update: XOR<incident_logsUpdateWithoutCrime_categoriesInput, incident_logsUncheckedUpdateWithoutCrime_categoriesInput>
    create: XOR<incident_logsCreateWithoutCrime_categoriesInput, incident_logsUncheckedCreateWithoutCrime_categoriesInput>
  }

  export type incident_logsUpdateWithWhereUniqueWithoutCrime_categoriesInput = {
    where: incident_logsWhereUniqueInput
    data: XOR<incident_logsUpdateWithoutCrime_categoriesInput, incident_logsUncheckedUpdateWithoutCrime_categoriesInput>
  }

  export type incident_logsUpdateManyWithWhereWithoutCrime_categoriesInput = {
    where: incident_logsScalarWhereInput
    data: XOR<incident_logsUpdateManyMutationInput, incident_logsUncheckedUpdateManyWithoutCrime_categoriesInput>
  }

  export type crime_incidentsCreateWithoutCrimesInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutCrimesInput = {
    id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutCrimesInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput>
  }

  export type crime_incidentsCreateManyCrimesInputEnvelope = {
    data: crime_incidentsCreateManyCrimesInput | crime_incidentsCreateManyCrimesInput[]
    skipDuplicates?: boolean
  }

  export type districtsCreateWithoutCrimesInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutCrimesInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutCrimesInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutCrimesInput, districtsUncheckedCreateWithoutCrimesInput>
  }

  export type crime_incidentsUpsertWithWhereUniqueWithoutCrimesInput = {
    where: crime_incidentsWhereUniqueInput
    update: XOR<crime_incidentsUpdateWithoutCrimesInput, crime_incidentsUncheckedUpdateWithoutCrimesInput>
    create: XOR<crime_incidentsCreateWithoutCrimesInput, crime_incidentsUncheckedCreateWithoutCrimesInput>
  }

  export type crime_incidentsUpdateWithWhereUniqueWithoutCrimesInput = {
    where: crime_incidentsWhereUniqueInput
    data: XOR<crime_incidentsUpdateWithoutCrimesInput, crime_incidentsUncheckedUpdateWithoutCrimesInput>
  }

  export type crime_incidentsUpdateManyWithWhereWithoutCrimesInput = {
    where: crime_incidentsScalarWhereInput
    data: XOR<crime_incidentsUpdateManyMutationInput, crime_incidentsUncheckedUpdateManyWithoutCrimesInput>
  }

  export type districtsUpsertWithoutCrimesInput = {
    update: XOR<districtsUpdateWithoutCrimesInput, districtsUncheckedUpdateWithoutCrimesInput>
    create: XOR<districtsCreateWithoutCrimesInput, districtsUncheckedCreateWithoutCrimesInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutCrimesInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutCrimesInput, districtsUncheckedUpdateWithoutCrimesInput>
  }

  export type districtsUpdateWithoutCrimesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutCrimesInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsCreateWithoutDemographicsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutDemographicsInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutDemographicsInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutDemographicsInput, districtsUncheckedCreateWithoutDemographicsInput>
  }

  export type districtsUpsertWithoutDemographicsInput = {
    update: XOR<districtsUpdateWithoutDemographicsInput, districtsUncheckedUpdateWithoutDemographicsInput>
    create: XOR<districtsCreateWithoutDemographicsInput, districtsUncheckedCreateWithoutDemographicsInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutDemographicsInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutDemographicsInput, districtsUncheckedUpdateWithoutDemographicsInput>
  }

  export type districtsUpdateWithoutDemographicsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutDemographicsInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type crimesCreateWithoutDistrictsInput = {
    id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
    crime_incidents?: crime_incidentsCreateNestedManyWithoutCrimesInput
  }

  export type crimesUncheckedCreateWithoutDistrictsInput = {
    id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
    crime_incidents?: crime_incidentsUncheckedCreateNestedManyWithoutCrimesInput
  }

  export type crimesCreateOrConnectWithoutDistrictsInput = {
    where: crimesWhereUniqueInput
    create: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput>
  }

  export type crimesCreateManyDistrictsInputEnvelope = {
    data: crimesCreateManyDistrictsInput | crimesCreateManyDistrictsInput[]
    skipDuplicates?: boolean
  }

  export type demographicsCreateWithoutDistrictsInput = {
    id?: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type demographicsUncheckedCreateWithoutDistrictsInput = {
    id?: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type demographicsCreateOrConnectWithoutDistrictsInput = {
    where: demographicsWhereUniqueInput
    create: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput>
  }

  export type demographicsCreateManyDistrictsInputEnvelope = {
    data: demographicsCreateManyDistrictsInput | demographicsCreateManyDistrictsInput[]
    skipDuplicates?: boolean
  }

  export type district_clustersCreateWithoutDistrictInput = {
    id?: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type district_clustersUncheckedCreateWithoutDistrictInput = {
    id?: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type district_clustersCreateOrConnectWithoutDistrictInput = {
    where: district_clustersWhereUniqueInput
    create: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput>
  }

  export type district_clustersCreateManyDistrictInputEnvelope = {
    data: district_clustersCreateManyDistrictInput | district_clustersCreateManyDistrictInput[]
    skipDuplicates?: boolean
  }

  export type citiesCreateWithoutDistrictsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    units?: unitsCreateNestedManyWithoutCitiesInput
  }

  export type citiesUncheckedCreateWithoutDistrictsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    units?: unitsUncheckedCreateNestedManyWithoutCitiesInput
  }

  export type citiesCreateOrConnectWithoutDistrictsInput = {
    where: citiesWhereUniqueInput
    create: XOR<citiesCreateWithoutDistrictsInput, citiesUncheckedCreateWithoutDistrictsInput>
  }

  export type crimesUpsertWithWhereUniqueWithoutDistrictsInput = {
    where: crimesWhereUniqueInput
    update: XOR<crimesUpdateWithoutDistrictsInput, crimesUncheckedUpdateWithoutDistrictsInput>
    create: XOR<crimesCreateWithoutDistrictsInput, crimesUncheckedCreateWithoutDistrictsInput>
  }

  export type crimesUpdateWithWhereUniqueWithoutDistrictsInput = {
    where: crimesWhereUniqueInput
    data: XOR<crimesUpdateWithoutDistrictsInput, crimesUncheckedUpdateWithoutDistrictsInput>
  }

  export type crimesUpdateManyWithWhereWithoutDistrictsInput = {
    where: crimesScalarWhereInput
    data: XOR<crimesUpdateManyMutationInput, crimesUncheckedUpdateManyWithoutDistrictsInput>
  }

  export type crimesScalarWhereInput = {
    AND?: crimesScalarWhereInput | crimesScalarWhereInput[]
    OR?: crimesScalarWhereInput[]
    NOT?: crimesScalarWhereInput | crimesScalarWhereInput[]
    id?: StringFilter<"crimes"> | string
    district_id?: StringFilter<"crimes"> | string
    created_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    level?: Enumcrime_ratesFilter<"crimes"> | $Enums.crime_rates
    method?: StringNullableFilter<"crimes"> | string | null
    month?: IntNullableFilter<"crimes"> | number | null
    number_of_crime?: IntFilter<"crimes"> | number
    score?: FloatFilter<"crimes"> | number
    updated_at?: DateTimeNullableFilter<"crimes"> | Date | string | null
    year?: IntNullableFilter<"crimes"> | number | null
    source_type?: StringNullableFilter<"crimes"> | string | null
    crime_cleared?: IntFilter<"crimes"> | number
    avg_crime?: FloatFilter<"crimes"> | number
  }

  export type demographicsUpsertWithWhereUniqueWithoutDistrictsInput = {
    where: demographicsWhereUniqueInput
    update: XOR<demographicsUpdateWithoutDistrictsInput, demographicsUncheckedUpdateWithoutDistrictsInput>
    create: XOR<demographicsCreateWithoutDistrictsInput, demographicsUncheckedCreateWithoutDistrictsInput>
  }

  export type demographicsUpdateWithWhereUniqueWithoutDistrictsInput = {
    where: demographicsWhereUniqueInput
    data: XOR<demographicsUpdateWithoutDistrictsInput, demographicsUncheckedUpdateWithoutDistrictsInput>
  }

  export type demographicsUpdateManyWithWhereWithoutDistrictsInput = {
    where: demographicsScalarWhereInput
    data: XOR<demographicsUpdateManyMutationInput, demographicsUncheckedUpdateManyWithoutDistrictsInput>
  }

  export type demographicsScalarWhereInput = {
    AND?: demographicsScalarWhereInput | demographicsScalarWhereInput[]
    OR?: demographicsScalarWhereInput[]
    NOT?: demographicsScalarWhereInput | demographicsScalarWhereInput[]
    id?: UuidFilter<"demographics"> | string
    district_id?: StringFilter<"demographics"> | string
    population?: IntFilter<"demographics"> | number
    number_of_unemployed?: IntFilter<"demographics"> | number
    population_density?: FloatFilter<"demographics"> | number
    year?: IntFilter<"demographics"> | number
    created_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"demographics"> | Date | string | null
  }

  export type district_clustersUpsertWithWhereUniqueWithoutDistrictInput = {
    where: district_clustersWhereUniqueInput
    update: XOR<district_clustersUpdateWithoutDistrictInput, district_clustersUncheckedUpdateWithoutDistrictInput>
    create: XOR<district_clustersCreateWithoutDistrictInput, district_clustersUncheckedCreateWithoutDistrictInput>
  }

  export type district_clustersUpdateWithWhereUniqueWithoutDistrictInput = {
    where: district_clustersWhereUniqueInput
    data: XOR<district_clustersUpdateWithoutDistrictInput, district_clustersUncheckedUpdateWithoutDistrictInput>
  }

  export type district_clustersUpdateManyWithWhereWithoutDistrictInput = {
    where: district_clustersScalarWhereInput
    data: XOR<district_clustersUpdateManyMutationInput, district_clustersUncheckedUpdateManyWithoutDistrictInput>
  }

  export type district_clustersScalarWhereInput = {
    AND?: district_clustersScalarWhereInput | district_clustersScalarWhereInput[]
    OR?: district_clustersScalarWhereInput[]
    NOT?: district_clustersScalarWhereInput | district_clustersScalarWhereInput[]
    id?: UuidFilter<"district_clusters"> | string
    district_id?: StringFilter<"district_clusters"> | string
    year?: IntFilter<"district_clusters"> | number
    month?: IntNullableFilter<"district_clusters"> | number | null
    risk_level?: Enumcrime_ratesFilter<"district_clusters"> | $Enums.crime_rates
    total_crimes?: IntFilter<"district_clusters"> | number
    population_density?: FloatFilter<"district_clusters"> | number
    unemployment_rate?: FloatFilter<"district_clusters"> | number
    crime_score?: FloatFilter<"district_clusters"> | number
    density_score?: FloatFilter<"district_clusters"> | number
    unemployment_score?: FloatFilter<"district_clusters"> | number
    cluster_score?: FloatFilter<"district_clusters"> | number
    centroid_features?: JsonNullableFilter<"district_clusters">
    member_count?: IntFilter<"district_clusters"> | number
    last_update_type?: StringFilter<"district_clusters"> | string
    update_count?: IntFilter<"district_clusters"> | number
    needs_recompute?: BoolFilter<"district_clusters"> | boolean
    incidents_data?: JsonNullableFilter<"district_clusters">
    created_at?: DateTimeFilter<"district_clusters"> | Date | string
    updated_at?: DateTimeFilter<"district_clusters"> | Date | string
  }

  export type citiesUpsertWithoutDistrictsInput = {
    update: XOR<citiesUpdateWithoutDistrictsInput, citiesUncheckedUpdateWithoutDistrictsInput>
    create: XOR<citiesCreateWithoutDistrictsInput, citiesUncheckedCreateWithoutDistrictsInput>
    where?: citiesWhereInput
  }

  export type citiesUpdateToOneWithWhereWithoutDistrictsInput = {
    where?: citiesWhereInput
    data: XOR<citiesUpdateWithoutDistrictsInput, citiesUncheckedUpdateWithoutDistrictsInput>
  }

  export type citiesUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    units?: unitsUpdateManyWithoutCitiesNestedInput
  }

  export type citiesUncheckedUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    units?: unitsUncheckedUpdateManyWithoutCitiesNestedInput
  }

  export type geographicsUpdateWithWhereUniqueWithoutDistrictsInput = {
    where: geographicsWhereUniqueInput
    data: XOR<geographicsUpdateWithoutDistrictsInput, geographicsUncheckedUpdateWithoutDistrictsInput>
  }

  export type geographicsUpdateManyWithWhereWithoutDistrictsInput = {
    where: geographicsScalarWhereInput
    data: XOR<geographicsUpdateManyMutationInput, geographicsUncheckedUpdateManyWithoutDistrictsInput>
  }

  export type geographicsScalarWhereInput = {
    AND?: geographicsScalarWhereInput | geographicsScalarWhereInput[]
    OR?: geographicsScalarWhereInput[]
    NOT?: geographicsScalarWhereInput | geographicsScalarWhereInput[]
    id?: UuidFilter<"geographics"> | string
    district_id?: StringFilter<"geographics"> | string
    address?: StringNullableFilter<"geographics"> | string | null
    longitude?: FloatFilter<"geographics"> | number
    latitude?: FloatFilter<"geographics"> | number
    land_area?: FloatNullableFilter<"geographics"> | number | null
    created_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"geographics"> | Date | string | null
    description?: StringNullableFilter<"geographics"> | string | null
    type?: StringNullableFilter<"geographics"> | string | null
    year?: IntNullableFilter<"geographics"> | number | null
  }

  export type locationsUpdateWithWhereUniqueWithoutDistrictsInput = {
    where: locationsWhereUniqueInput
    data: XOR<locationsUpdateWithoutDistrictsInput, locationsUncheckedUpdateWithoutDistrictsInput>
  }

  export type locationsUpdateManyWithWhereWithoutDistrictsInput = {
    where: locationsScalarWhereInput
    data: XOR<locationsUpdateManyMutationInput, locationsUncheckedUpdateManyWithoutDistrictsInput>
  }

  export type unitsUpdateToOneWithWhereWithoutDistrictsInput = {
    where?: unitsWhereInput
    data: XOR<unitsUpdateWithoutDistrictsInput, unitsUncheckedUpdateWithoutDistrictsInput>
  }

  export type unitsUpdateWithoutDistrictsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUpdateManyWithoutUnitsNestedInput
    cities?: citiesUpdateOneRequiredWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateWithoutDistrictsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUncheckedUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput
  }

  export type crime_incidentsCreateWithoutLocationsInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutLocationsInput = {
    id: string
    crime_id: string
    crime_category_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutLocationsInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutLocationsInput, crime_incidentsUncheckedCreateWithoutLocationsInput>
  }

  export type crime_incidentsUpsertWithWhereUniqueWithoutLocationsInput = {
    where: crime_incidentsWhereUniqueInput
    update: XOR<crime_incidentsUpdateWithoutLocationsInput, crime_incidentsUncheckedUpdateWithoutLocationsInput>
    create: XOR<crime_incidentsCreateWithoutLocationsInput, crime_incidentsUncheckedCreateWithoutLocationsInput>
  }

  export type crime_incidentsCreateManyLocationsInputEnvelope = {
    data: crime_incidentsCreateManyLocationsInput | crime_incidentsCreateManyLocationsInput[]
    skipDuplicates?: boolean
  }

  export type crime_incidentsUpdateWithWhereUniqueWithoutLocationsInput = {
    where: crime_incidentsWhereUniqueInput
    data: XOR<crime_incidentsUpdateWithoutLocationsInput, crime_incidentsUncheckedUpdateWithoutLocationsInput>
  }

  export type crime_incidentsUpdateManyWithWhereWithoutLocationsInput = {
    where: crime_incidentsScalarWhereInput
    data: XOR<crime_incidentsUpdateManyMutationInput, crime_incidentsUncheckedUpdateManyWithoutLocationsInput>
  }

  export type incident_logsCreateWithoutLocationsInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutLocationsInput = {
    id?: string
    user_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutLocationsInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutLocationsInput, incident_logsUncheckedCreateWithoutLocationsInput>
  }

  export type incident_logsUpsertWithWhereUniqueWithoutLocationsInput = {
    where: incident_logsWhereUniqueInput
    update: XOR<incident_logsUpdateWithoutLocationsInput, incident_logsUncheckedUpdateWithoutLocationsInput>
    create: XOR<incident_logsCreateWithoutLocationsInput, incident_logsUncheckedCreateWithoutLocationsInput>
  }

  export type incident_logsCreateManyLocationsInputEnvelope = {
    data: incident_logsCreateManyLocationsInput | incident_logsCreateManyLocationsInput[]
    skipDuplicates?: boolean
  }

  export type incident_logsUpdateWithWhereUniqueWithoutLocationsInput = {
    where: incident_logsWhereUniqueInput
    data: XOR<incident_logsUpdateWithoutLocationsInput, incident_logsUncheckedUpdateWithoutLocationsInput>
  }

  export type incident_logsUpdateManyWithWhereWithoutLocationsInput = {
    where: incident_logsScalarWhereInput
    data: XOR<incident_logsUpdateManyMutationInput, incident_logsUncheckedUpdateManyWithoutLocationsInput>
  }

  export type location_logsUpdateWithWhereUniqueWithoutLocationInput = {
    where: location_logsWhereUniqueInput
    data: XOR<location_logsUpdateWithoutLocationInput, location_logsUncheckedUpdateWithoutLocationInput>
  }

  export type location_logsUpdateManyWithWhereWithoutLocationInput = {
    where: location_logsScalarWhereInput
    data: XOR<location_logsUpdateManyMutationInput, location_logsUncheckedUpdateManyWithoutLocationInput>
  }

  export type location_logsScalarWhereInput = {
    AND?: location_logsScalarWhereInput | location_logsScalarWhereInput[]
    OR?: location_logsScalarWhereInput[]
    NOT?: location_logsScalarWhereInput | location_logsScalarWhereInput[]
    id?: UuidFilter<"location_logs"> | string
    location_id?: UuidFilter<"location_logs"> | string
    latitude?: FloatFilter<"location_logs"> | number
    longitude?: FloatFilter<"location_logs"> | number
    timestamp?: DateTimeFilter<"location_logs"> | Date | string
    description?: StringNullableFilter<"location_logs"> | string | null
    created_at?: DateTimeFilter<"location_logs"> | Date | string
    updated_at?: DateTimeFilter<"location_logs"> | Date | string
  }

  export type districtsCreateWithoutLocationsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutLocationsInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutLocationsInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutLocationsInput, districtsUncheckedCreateWithoutLocationsInput>
  }

  export type districtsUpsertWithoutLocationsInput = {
    update: XOR<districtsUpdateWithoutLocationsInput, districtsUncheckedUpdateWithoutLocationsInput>
    create: XOR<districtsCreateWithoutLocationsInput, districtsUncheckedCreateWithoutLocationsInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutLocationsInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutLocationsInput, districtsUncheckedUpdateWithoutLocationsInput>
  }

  export type districtsUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type eventsCreateWithoutLocationsInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    users: usersCreateNestedOneWithoutEventsInput
    sessions?: sessionsCreateNestedManyWithoutEventInput
  }

  export type eventsUncheckedCreateWithoutLocationsInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
    user_id: string
    sessions?: sessionsUncheckedCreateNestedManyWithoutEventInput
  }

  export type eventsCreateOrConnectWithoutLocationsInput = {
    where: eventsWhereUniqueInput
    create: XOR<eventsCreateWithoutLocationsInput, eventsUncheckedCreateWithoutLocationsInput>
  }

  export type eventsUpsertWithoutLocationsInput = {
    update: XOR<eventsUpdateWithoutLocationsInput, eventsUncheckedUpdateWithoutLocationsInput>
    create: XOR<eventsCreateWithoutLocationsInput, eventsUncheckedCreateWithoutLocationsInput>
    where?: eventsWhereInput
  }

  export type eventsUpdateToOneWithWhereWithoutLocationsInput = {
    where?: eventsWhereInput
    data: XOR<eventsUpdateWithoutLocationsInput, eventsUncheckedUpdateWithoutLocationsInput>
  }

  export type eventsUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutEventsNestedInput
    sessions?: sessionsUpdateManyWithoutEventNestedInput
  }

  export type eventsUncheckedUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user_id?: StringFieldUpdateOperationsInput | string
    sessions?: sessionsUncheckedUpdateManyWithoutEventNestedInput
  }

  export type patrol_unitsCreateWithoutLocationInput = {
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersCreateNestedManyWithoutPatrol_unitsInput
    unit: unitsCreateNestedOneWithoutPatrol_unitsInput
  }

  export type patrol_unitsUncheckedCreateWithoutLocationInput = {
    unit_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersUncheckedCreateNestedManyWithoutPatrol_unitsInput
  }

  export type patrol_unitsCreateOrConnectWithoutLocationInput = {
    where: patrol_unitsWhereUniqueInput
    create: XOR<patrol_unitsCreateWithoutLocationInput, patrol_unitsUncheckedCreateWithoutLocationInput>
  }

  export type patrol_unitsUpsertWithWhereUniqueWithoutLocationInput = {
    where: patrol_unitsWhereUniqueInput
    update: XOR<patrol_unitsUpdateWithoutLocationInput, patrol_unitsUncheckedUpdateWithoutLocationInput>
    create: XOR<patrol_unitsCreateWithoutLocationInput, patrol_unitsUncheckedCreateWithoutLocationInput>
  }

  export type patrol_unitsCreateManyLocationInputEnvelope = {
    data: patrol_unitsCreateManyLocationInput | patrol_unitsCreateManyLocationInput[]
    skipDuplicates?: boolean
  }

  export type patrol_unitsUpdateWithWhereUniqueWithoutLocationInput = {
    where: patrol_unitsWhereUniqueInput
    data: XOR<patrol_unitsUpdateWithoutLocationInput, patrol_unitsUncheckedUpdateWithoutLocationInput>
  }

  export type patrol_unitsUpdateManyWithWhereWithoutLocationInput = {
    where: patrol_unitsScalarWhereInput
    data: XOR<patrol_unitsUpdateManyMutationInput, patrol_unitsUncheckedUpdateManyWithoutLocationInput>
  }

  export type patrol_unitsScalarWhereInput = {
    AND?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
    OR?: patrol_unitsScalarWhereInput[]
    NOT?: patrol_unitsScalarWhereInput | patrol_unitsScalarWhereInput[]
    unit_id?: StringFilter<"patrol_units"> | string
    location_id?: UuidFilter<"patrol_units"> | string
    name?: StringFilter<"patrol_units"> | string
    type?: StringFilter<"patrol_units"> | string
    status?: StringFilter<"patrol_units"> | string
    radius?: FloatFilter<"patrol_units"> | number
    created_at?: DateTimeFilter<"patrol_units"> | Date | string
    id?: StringFilter<"patrol_units"> | string
    category?: Enumpatrol_unit_categoryNullableFilter<"patrol_units"> | $Enums.patrol_unit_category | null
    member_count?: IntNullableFilter<"patrol_units"> | number | null
    updated_at?: DateTimeNullableFilter<"patrol_units"> | Date | string | null
  }

  export type evidenceCreateWithoutIncidentInput = {
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
    crime_incidents?: crime_incidentsCreateNestedOneWithoutEvidencesInput
  }

  export type evidenceUncheckedCreateWithoutIncidentInput = {
    crime_incidents_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type evidenceCreateOrConnectWithoutIncidentInput = {
    where: evidenceWhereUniqueInput
    create: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput>
  }

  export type evidenceCreateManyIncidentInputEnvelope = {
    data: evidenceCreateManyIncidentInput | evidenceCreateManyIncidentInput[]
    skipDuplicates?: boolean
  }

  export type crime_categoriesCreateWithoutIncident_logsInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    crime_incidents?: crime_incidentsCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesUncheckedCreateWithoutIncident_logsInput = {
    id: string
    name: string
    description: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    type?: string | null
    crime_incidents?: crime_incidentsUncheckedCreateNestedManyWithoutCrime_categoriesInput
  }

  export type crime_categoriesCreateOrConnectWithoutIncident_logsInput = {
    where: crime_categoriesWhereUniqueInput
    create: XOR<crime_categoriesCreateWithoutIncident_logsInput, crime_categoriesUncheckedCreateWithoutIncident_logsInput>
  }

  export type usersCreateWithoutIncident_logsInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutIncident_logsInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutIncident_logsInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutIncident_logsInput, usersUncheckedCreateWithoutIncident_logsInput>
  }

  export type panic_button_logsCreateWithoutIncidentsInput = {
    id?: string
    timestamp?: Date | string
    officers?: officersCreateNestedOneWithoutPanic_button_logsInput
    users: usersCreateNestedOneWithoutPanic_button_logsInput
  }

  export type panic_button_logsUncheckedCreateWithoutIncidentsInput = {
    id?: string
    user_id: string
    officer_id?: string | null
    timestamp?: Date | string
  }

  export type panic_button_logsCreateOrConnectWithoutIncidentsInput = {
    where: panic_button_logsWhereUniqueInput
    create: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput>
  }

  export type panic_button_logsCreateManyIncidentsInputEnvelope = {
    data: panic_button_logsCreateManyIncidentsInput | panic_button_logsCreateManyIncidentsInput[]
    skipDuplicates?: boolean
  }

  export type timelinesCreateWithoutIncidentInput = {
    id?: string
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_incidents?: crime_incidentsCreateNestedOneWithoutTimelinesInput
    user?: usersCreateNestedOneWithoutTimelinesInput
  }

  export type timelinesUncheckedCreateWithoutIncidentInput = {
    id?: string
    crime_incidents_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type timelinesCreateOrConnectWithoutIncidentInput = {
    where: timelinesWhereUniqueInput
    create: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput>
  }

  export type timelinesCreateManyIncidentInputEnvelope = {
    data: timelinesCreateManyIncidentInput | timelinesCreateManyIncidentInput[]
    skipDuplicates?: boolean
  }

  export type witnessesCreateWithoutIncidentInput = {
    id?: string
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_incidents?: crime_incidentsCreateNestedOneWithoutWitnessesInput
  }

  export type witnessesUncheckedCreateWithoutIncidentInput = {
    id?: string
    crime_incidents_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesCreateOrConnectWithoutIncidentInput = {
    where: witnessesWhereUniqueInput
    create: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput>
  }

  export type witnessesCreateManyIncidentInputEnvelope = {
    data: witnessesCreateManyIncidentInput | witnessesCreateManyIncidentInput[]
    skipDuplicates?: boolean
  }

  export type evidenceUpsertWithWhereUniqueWithoutIncidentInput = {
    where: evidenceWhereUniqueInput
    update: XOR<evidenceUpdateWithoutIncidentInput, evidenceUncheckedUpdateWithoutIncidentInput>
    create: XOR<evidenceCreateWithoutIncidentInput, evidenceUncheckedCreateWithoutIncidentInput>
  }

  export type evidenceUpdateWithWhereUniqueWithoutIncidentInput = {
    where: evidenceWhereUniqueInput
    data: XOR<evidenceUpdateWithoutIncidentInput, evidenceUncheckedUpdateWithoutIncidentInput>
  }

  export type evidenceUpdateManyWithWhereWithoutIncidentInput = {
    where: evidenceScalarWhereInput
    data: XOR<evidenceUpdateManyMutationInput, evidenceUncheckedUpdateManyWithoutIncidentInput>
  }

  export type crime_categoriesUpsertWithoutIncident_logsInput = {
    update: XOR<crime_categoriesUpdateWithoutIncident_logsInput, crime_categoriesUncheckedUpdateWithoutIncident_logsInput>
    create: XOR<crime_categoriesCreateWithoutIncident_logsInput, crime_categoriesUncheckedCreateWithoutIncident_logsInput>
    where?: crime_categoriesWhereInput
  }

  export type crime_categoriesUpdateToOneWithWhereWithoutIncident_logsInput = {
    where?: crime_categoriesWhereInput
    data: XOR<crime_categoriesUpdateWithoutIncident_logsInput, crime_categoriesUncheckedUpdateWithoutIncident_logsInput>
  }

  export type crime_categoriesUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents?: crime_incidentsUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type crime_categoriesUncheckedUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutCrime_categoriesNestedInput
  }

  export type locationsUpdateToOneWithWhereWithoutIncident_logsInput = {
    where?: locationsWhereInput
    data: XOR<locationsUpdateWithoutIncident_logsInput, locationsUncheckedUpdateWithoutIncident_logsInput>
  }

  export type locationsUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type usersUpsertWithoutIncident_logsInput = {
    update: XOR<usersUpdateWithoutIncident_logsInput, usersUncheckedUpdateWithoutIncident_logsInput>
    create: XOR<usersCreateWithoutIncident_logsInput, usersUncheckedCreateWithoutIncident_logsInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutIncident_logsInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutIncident_logsInput, usersUncheckedUpdateWithoutIncident_logsInput>
  }

  export type usersUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutIncident_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type panic_button_logsUpsertWithWhereUniqueWithoutIncidentsInput = {
    where: panic_button_logsWhereUniqueInput
    update: XOR<panic_button_logsUpdateWithoutIncidentsInput, panic_button_logsUncheckedUpdateWithoutIncidentsInput>
    create: XOR<panic_button_logsCreateWithoutIncidentsInput, panic_button_logsUncheckedCreateWithoutIncidentsInput>
  }

  export type panic_button_logsUpdateWithWhereUniqueWithoutIncidentsInput = {
    where: panic_button_logsWhereUniqueInput
    data: XOR<panic_button_logsUpdateWithoutIncidentsInput, panic_button_logsUncheckedUpdateWithoutIncidentsInput>
  }

  export type panic_button_logsUpdateManyWithWhereWithoutIncidentsInput = {
    where: panic_button_logsScalarWhereInput
    data: XOR<panic_button_logsUpdateManyMutationInput, panic_button_logsUncheckedUpdateManyWithoutIncidentsInput>
  }

  export type timelinesUpsertWithWhereUniqueWithoutIncidentInput = {
    where: timelinesWhereUniqueInput
    update: XOR<timelinesUpdateWithoutIncidentInput, timelinesUncheckedUpdateWithoutIncidentInput>
    create: XOR<timelinesCreateWithoutIncidentInput, timelinesUncheckedCreateWithoutIncidentInput>
  }

  export type timelinesUpdateWithWhereUniqueWithoutIncidentInput = {
    where: timelinesWhereUniqueInput
    data: XOR<timelinesUpdateWithoutIncidentInput, timelinesUncheckedUpdateWithoutIncidentInput>
  }

  export type timelinesUpdateManyWithWhereWithoutIncidentInput = {
    where: timelinesScalarWhereInput
    data: XOR<timelinesUpdateManyMutationInput, timelinesUncheckedUpdateManyWithoutIncidentInput>
  }

  export type witnessesUpsertWithWhereUniqueWithoutIncidentInput = {
    where: witnessesWhereUniqueInput
    update: XOR<witnessesUpdateWithoutIncidentInput, witnessesUncheckedUpdateWithoutIncidentInput>
    create: XOR<witnessesCreateWithoutIncidentInput, witnessesUncheckedCreateWithoutIncidentInput>
  }

  export type witnessesUpdateWithWhereUniqueWithoutIncidentInput = {
    where: witnessesWhereUniqueInput
    data: XOR<witnessesUpdateWithoutIncidentInput, witnessesUncheckedUpdateWithoutIncidentInput>
  }

  export type witnessesUpdateManyWithWhereWithoutIncidentInput = {
    where: witnessesScalarWhereInput
    data: XOR<witnessesUpdateManyMutationInput, witnessesUncheckedUpdateManyWithoutIncidentInput>
  }

  export type crime_incidentsCreateWithoutTimelinesInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutTimelinesInput = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutTimelinesInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutTimelinesInput, crime_incidentsUncheckedCreateWithoutTimelinesInput>
  }

  export type incident_logsCreateWithoutTimelinesInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutTimelinesInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutTimelinesInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutTimelinesInput, incident_logsUncheckedCreateWithoutTimelinesInput>
  }

  export type usersCreateWithoutTimelinesInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutTimelinesInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutTimelinesInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutTimelinesInput, usersUncheckedCreateWithoutTimelinesInput>
  }

  export type crime_incidentsUpsertWithoutTimelinesInput = {
    update: XOR<crime_incidentsUpdateWithoutTimelinesInput, crime_incidentsUncheckedUpdateWithoutTimelinesInput>
    create: XOR<crime_incidentsCreateWithoutTimelinesInput, crime_incidentsUncheckedCreateWithoutTimelinesInput>
    where?: crime_incidentsWhereInput
  }

  export type crime_incidentsUpdateToOneWithWhereWithoutTimelinesInput = {
    where?: crime_incidentsWhereInput
    data: XOR<crime_incidentsUpdateWithoutTimelinesInput, crime_incidentsUncheckedUpdateWithoutTimelinesInput>
  }

  export type crime_incidentsUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type incident_logsUpsertWithoutTimelinesInput = {
    update: XOR<incident_logsUpdateWithoutTimelinesInput, incident_logsUncheckedUpdateWithoutTimelinesInput>
    create: XOR<incident_logsCreateWithoutTimelinesInput, incident_logsUncheckedCreateWithoutTimelinesInput>
    where?: incident_logsWhereInput
  }

  export type incident_logsUpdateToOneWithWhereWithoutTimelinesInput = {
    where?: incident_logsWhereInput
    data: XOR<incident_logsUpdateWithoutTimelinesInput, incident_logsUncheckedUpdateWithoutTimelinesInput>
  }

  export type incident_logsUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type usersUpsertWithoutTimelinesInput = {
    update: XOR<usersUpdateWithoutTimelinesInput, usersUncheckedUpdateWithoutTimelinesInput>
    create: XOR<usersCreateWithoutTimelinesInput, usersUncheckedCreateWithoutTimelinesInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutTimelinesInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutTimelinesInput, usersUncheckedUpdateWithoutTimelinesInput>
  }

  export type usersUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutTimelinesInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type crime_incidentsCreateWithoutWitnessesInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    evidences?: evidenceCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutWitnessesInput = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    evidences?: evidenceUncheckedCreateNestedManyWithoutCrime_incidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutWitnessesInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutWitnessesInput, crime_incidentsUncheckedCreateWithoutWitnessesInput>
  }

  export type incident_logsCreateWithoutWitnessesInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutWitnessesInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutWitnessesInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutWitnessesInput, incident_logsUncheckedCreateWithoutWitnessesInput>
  }

  export type crime_incidentsUpsertWithoutWitnessesInput = {
    update: XOR<crime_incidentsUpdateWithoutWitnessesInput, crime_incidentsUncheckedUpdateWithoutWitnessesInput>
    create: XOR<crime_incidentsCreateWithoutWitnessesInput, crime_incidentsUncheckedCreateWithoutWitnessesInput>
    where?: crime_incidentsWhereInput
  }

  export type crime_incidentsUpdateToOneWithWhereWithoutWitnessesInput = {
    where?: crime_incidentsWhereInput
    data: XOR<crime_incidentsUpdateWithoutWitnessesInput, crime_incidentsUncheckedUpdateWithoutWitnessesInput>
  }

  export type crime_incidentsUpdateWithoutWitnessesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutWitnessesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type incident_logsUpsertWithoutWitnessesInput = {
    update: XOR<incident_logsUpdateWithoutWitnessesInput, incident_logsUncheckedUpdateWithoutWitnessesInput>
    create: XOR<incident_logsCreateWithoutWitnessesInput, incident_logsUncheckedCreateWithoutWitnessesInput>
    where?: incident_logsWhereInput
  }

  export type incident_logsUpdateToOneWithWhereWithoutWitnessesInput = {
    where?: incident_logsWhereInput
    data: XOR<incident_logsUpdateWithoutWitnessesInput, incident_logsUncheckedUpdateWithoutWitnessesInput>
  }

  export type incident_logsUpdateWithoutWitnessesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutWitnessesInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type crime_incidentsCreateWithoutEvidencesInput = {
    id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    crime_categories: crime_categoriesCreateNestedOneWithoutCrime_incidentsInput
    crimes: crimesCreateNestedOneWithoutCrime_incidentsInput
    locations: locationsCreateNestedOneWithoutCrime_incidentsInput
    timelines?: timelinesCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsUncheckedCreateWithoutEvidencesInput = {
    id: string
    crime_id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
    timelines?: timelinesUncheckedCreateNestedManyWithoutCrime_incidentsInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutCrime_incidentsInput
  }

  export type crime_incidentsCreateOrConnectWithoutEvidencesInput = {
    where: crime_incidentsWhereUniqueInput
    create: XOR<crime_incidentsCreateWithoutEvidencesInput, crime_incidentsUncheckedCreateWithoutEvidencesInput>
  }

  export type incident_logsCreateWithoutEvidenceInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutEvidenceInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutIncidentsInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutEvidenceInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutEvidenceInput, incident_logsUncheckedCreateWithoutEvidenceInput>
  }

  export type crime_incidentsUpsertWithoutEvidencesInput = {
    update: XOR<crime_incidentsUpdateWithoutEvidencesInput, crime_incidentsUncheckedUpdateWithoutEvidencesInput>
    create: XOR<crime_incidentsCreateWithoutEvidencesInput, crime_incidentsUncheckedCreateWithoutEvidencesInput>
    where?: crime_incidentsWhereInput
  }

  export type crime_incidentsUpdateToOneWithWhereWithoutEvidencesInput = {
    where?: crime_incidentsWhereInput
    data: XOR<crime_incidentsUpdateWithoutEvidencesInput, crime_incidentsUncheckedUpdateWithoutEvidencesInput>
  }

  export type crime_incidentsUpdateWithoutEvidencesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutEvidencesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type incident_logsUpsertWithoutEvidenceInput = {
    update: XOR<incident_logsUpdateWithoutEvidenceInput, incident_logsUncheckedUpdateWithoutEvidenceInput>
    create: XOR<incident_logsCreateWithoutEvidenceInput, incident_logsUncheckedCreateWithoutEvidenceInput>
    where?: incident_logsWhereInput
  }

  export type incident_logsUpdateToOneWithWhereWithoutEvidenceInput = {
    where?: incident_logsWhereInput
    data: XOR<incident_logsUpdateWithoutEvidenceInput, incident_logsUncheckedUpdateWithoutEvidenceInput>
  }

  export type incident_logsUpdateWithoutEvidenceInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutEvidenceInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type officersCreateWithoutUnitsInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutUnitsInput = {
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutUnitsInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutUnitsInput, officersUncheckedCreateWithoutUnitsInput>
  }

  export type officersUpsertWithWhereUniqueWithoutUnitsInput = {
    where: officersWhereUniqueInput
    update: XOR<officersUpdateWithoutUnitsInput, officersUncheckedUpdateWithoutUnitsInput>
    create: XOR<officersCreateWithoutUnitsInput, officersUncheckedCreateWithoutUnitsInput>
  }

  export type officersCreateManyUnitsInputEnvelope = {
    data: officersCreateManyUnitsInput | officersCreateManyUnitsInput[]
    skipDuplicates?: boolean
  }

  export type officersUpdateWithWhereUniqueWithoutUnitsInput = {
    where: officersWhereUniqueInput
    data: XOR<officersUpdateWithoutUnitsInput, officersUncheckedUpdateWithoutUnitsInput>
  }

  export type officersUpdateManyWithWhereWithoutUnitsInput = {
    where: officersScalarWhereInput
    data: XOR<officersUpdateManyMutationInput, officersUncheckedUpdateManyWithoutUnitsInput>
  }

  export type patrol_unitsCreateWithoutUnitInput = {
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersCreateNestedManyWithoutPatrol_unitsInput
    location: locationsCreateNestedOneWithoutPatrol_unitsInput
  }

  export type patrol_unitsUncheckedCreateWithoutUnitInput = {
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    members?: officersUncheckedCreateNestedManyWithoutPatrol_unitsInput
  }

  export type patrol_unitsCreateOrConnectWithoutUnitInput = {
    where: patrol_unitsWhereUniqueInput
    create: XOR<patrol_unitsCreateWithoutUnitInput, patrol_unitsUncheckedCreateWithoutUnitInput>
  }

  export type patrol_unitsUpsertWithWhereUniqueWithoutUnitInput = {
    where: patrol_unitsWhereUniqueInput
    update: XOR<patrol_unitsUpdateWithoutUnitInput, patrol_unitsUncheckedUpdateWithoutUnitInput>
    create: XOR<patrol_unitsCreateWithoutUnitInput, patrol_unitsUncheckedCreateWithoutUnitInput>
  }

  export type patrol_unitsCreateManyUnitInputEnvelope = {
    data: patrol_unitsCreateManyUnitInput | patrol_unitsCreateManyUnitInput[]
    skipDuplicates?: boolean
  }

  export type patrol_unitsUpdateWithWhereUniqueWithoutUnitInput = {
    where: patrol_unitsWhereUniqueInput
    data: XOR<patrol_unitsUpdateWithoutUnitInput, patrol_unitsUncheckedUpdateWithoutUnitInput>
  }

  export type patrol_unitsUpdateManyWithWhereWithoutUnitInput = {
    where: patrol_unitsScalarWhereInput
    data: XOR<patrol_unitsUpdateManyMutationInput, patrol_unitsUncheckedUpdateManyWithoutUnitInput>
  }

  export type unit_statisticsCreateWithoutUnitsInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type unit_statisticsUncheckedCreateWithoutUnitsInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type unit_statisticsCreateOrConnectWithoutUnitsInput = {
    where: unit_statisticsWhereUniqueInput
    create: XOR<unit_statisticsCreateWithoutUnitsInput, unit_statisticsUncheckedCreateWithoutUnitsInput>
  }

  export type unit_statisticsUpsertWithWhereUniqueWithoutUnitsInput = {
    where: unit_statisticsWhereUniqueInput
    update: XOR<unit_statisticsUpdateWithoutUnitsInput, unit_statisticsUncheckedUpdateWithoutUnitsInput>
    create: XOR<unit_statisticsCreateWithoutUnitsInput, unit_statisticsUncheckedCreateWithoutUnitsInput>
  }

  export type unit_statisticsCreateManyUnitsInputEnvelope = {
    data: unit_statisticsCreateManyUnitsInput | unit_statisticsCreateManyUnitsInput[]
    skipDuplicates?: boolean
  }

  export type unit_statisticsUpdateWithWhereUniqueWithoutUnitsInput = {
    where: unit_statisticsWhereUniqueInput
    data: XOR<unit_statisticsUpdateWithoutUnitsInput, unit_statisticsUncheckedUpdateWithoutUnitsInput>
  }

  export type unit_statisticsUpdateManyWithWhereWithoutUnitsInput = {
    where: unit_statisticsScalarWhereInput
    data: XOR<unit_statisticsUpdateManyMutationInput, unit_statisticsUncheckedUpdateManyWithoutUnitsInput>
  }

  export type unit_statisticsScalarWhereInput = {
    AND?: unit_statisticsScalarWhereInput | unit_statisticsScalarWhereInput[]
    OR?: unit_statisticsScalarWhereInput[]
    NOT?: unit_statisticsScalarWhereInput | unit_statisticsScalarWhereInput[]
    id?: UuidFilter<"unit_statistics"> | string
    crime_total?: IntFilter<"unit_statistics"> | number
    crime_cleared?: IntFilter<"unit_statistics"> | number
    percentage?: FloatNullableFilter<"unit_statistics"> | number | null
    pending?: IntNullableFilter<"unit_statistics"> | number | null
    month?: IntFilter<"unit_statistics"> | number
    year?: IntFilter<"unit_statistics"> | number
    created_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    updated_at?: DateTimeNullableFilter<"unit_statistics"> | Date | string | null
    code_unit?: StringFilter<"unit_statistics"> | string
  }

  export type citiesCreateWithoutUnitsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    districts?: districtsCreateNestedManyWithoutCitiesInput
  }

  export type citiesUncheckedCreateWithoutUnitsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    districts?: districtsUncheckedCreateNestedManyWithoutCitiesInput
  }

  export type citiesCreateOrConnectWithoutUnitsInput = {
    where: citiesWhereUniqueInput
    create: XOR<citiesCreateWithoutUnitsInput, citiesUncheckedCreateWithoutUnitsInput>
  }

  export type citiesUpsertWithoutUnitsInput = {
    update: XOR<citiesUpdateWithoutUnitsInput, citiesUncheckedUpdateWithoutUnitsInput>
    create: XOR<citiesCreateWithoutUnitsInput, citiesUncheckedCreateWithoutUnitsInput>
    where?: citiesWhereInput
  }

  export type citiesUpdateToOneWithWhereWithoutUnitsInput = {
    where?: citiesWhereInput
    data: XOR<citiesUpdateWithoutUnitsInput, citiesUncheckedUpdateWithoutUnitsInput>
  }

  export type citiesUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    districts?: districtsUpdateManyWithoutCitiesNestedInput
  }

  export type citiesUncheckedUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    districts?: districtsUncheckedUpdateManyWithoutCitiesNestedInput
  }

  export type districtsCreateWithoutUnitsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutUnitsInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutUnitsInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutUnitsInput, districtsUncheckedCreateWithoutUnitsInput>
  }

  export type districtsUpsertWithoutUnitsInput = {
    update: XOR<districtsUpdateWithoutUnitsInput, districtsUncheckedUpdateWithoutUnitsInput>
    create: XOR<districtsCreateWithoutUnitsInput, districtsUncheckedCreateWithoutUnitsInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutUnitsInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutUnitsInput, districtsUncheckedUpdateWithoutUnitsInput>
  }

  export type districtsUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
  }

  export type officersCreateWithoutPatrol_unitsInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutPatrol_unitsInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutPatrol_unitsInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput>
  }

  export type officersCreateManyPatrol_unitsInputEnvelope = {
    data: officersCreateManyPatrol_unitsInput | officersCreateManyPatrol_unitsInput[]
    skipDuplicates?: boolean
  }

  export type officersUpsertWithWhereUniqueWithoutPatrol_unitsInput = {
    where: officersWhereUniqueInput
    update: XOR<officersUpdateWithoutPatrol_unitsInput, officersUncheckedUpdateWithoutPatrol_unitsInput>
    create: XOR<officersCreateWithoutPatrol_unitsInput, officersUncheckedCreateWithoutPatrol_unitsInput>
  }

  export type officersUpdateWithWhereUniqueWithoutPatrol_unitsInput = {
    where: officersWhereUniqueInput
    data: XOR<officersUpdateWithoutPatrol_unitsInput, officersUncheckedUpdateWithoutPatrol_unitsInput>
  }

  export type officersUpdateManyWithWhereWithoutPatrol_unitsInput = {
    where: officersScalarWhereInput
    data: XOR<officersUpdateManyMutationInput, officersUncheckedUpdateManyWithoutPatrol_unitsInput>
  }

  export type locationsUpdateToOneWithWhereWithoutPatrol_unitsInput = {
    where?: locationsWhereInput
    data: XOR<locationsUpdateWithoutPatrol_unitsInput, locationsUncheckedUpdateWithoutPatrol_unitsInput>
  }

  export type locationsUpdateWithoutPatrol_unitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
  }

  export type locationsUncheckedUpdateWithoutPatrol_unitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type unitsUpdateToOneWithWhereWithoutPatrol_unitsInput = {
    where?: unitsWhereInput
    data: XOR<unitsUpdateWithoutPatrol_unitsInput, unitsUncheckedUpdateWithoutPatrol_unitsInput>
  }

  export type unitsUpdateWithoutPatrol_unitsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUpdateManyWithoutUnitsNestedInput
    unit_statistics?: unit_statisticsUpdateManyWithoutUnitsNestedInput
    cities?: citiesUpdateOneRequiredWithoutUnitsNestedInput
    districts?: districtsUpdateOneWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateWithoutPatrol_unitsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUncheckedUpdateManyWithoutUnitsNestedInput
    unit_statistics?: unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput
  }

  export type patrol_unitsCreateWithoutMembersInput = {
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
    location: locationsCreateNestedOneWithoutPatrol_unitsInput
    unit: unitsCreateNestedOneWithoutPatrol_unitsInput
  }

  export type patrol_unitsUncheckedCreateWithoutMembersInput = {
    unit_id: string
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
  }

  export type patrol_unitsCreateOrConnectWithoutMembersInput = {
    where: patrol_unitsWhereUniqueInput
    create: XOR<patrol_unitsCreateWithoutMembersInput, patrol_unitsUncheckedCreateWithoutMembersInput>
  }

  export type rolesCreateWithoutOfficersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    permissions?: permissionsCreateNestedManyWithoutRoleInput
    users?: usersCreateNestedManyWithoutRoleInput
  }

  export type rolesUncheckedCreateWithoutOfficersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    permissions?: permissionsUncheckedCreateNestedManyWithoutRoleInput
    users?: usersUncheckedCreateNestedManyWithoutRoleInput
  }

  export type rolesCreateOrConnectWithoutOfficersInput = {
    where: rolesWhereUniqueInput
    create: XOR<rolesCreateWithoutOfficersInput, rolesUncheckedCreateWithoutOfficersInput>
  }

  export type panic_button_logsCreateWithoutOfficersInput = {
    id?: string
    timestamp?: Date | string
    incidents: incident_logsCreateNestedOneWithoutPanic_button_logsInput
    users: usersCreateNestedOneWithoutPanic_button_logsInput
  }

  export type panic_button_logsUncheckedCreateWithoutOfficersInput = {
    id?: string
    user_id: string
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type panic_button_logsCreateOrConnectWithoutOfficersInput = {
    where: panic_button_logsWhereUniqueInput
    create: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput>
  }

  export type panic_button_logsCreateManyOfficersInputEnvelope = {
    data: panic_button_logsCreateManyOfficersInput | panic_button_logsCreateManyOfficersInput[]
    skipDuplicates?: boolean
  }

  export type messagesCreateWithoutSender_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_user?: usersCreateNestedOneWithoutSentMessagesInput
    recipient_user?: usersCreateNestedOneWithoutReceivedMessagesInput
    recipient_officer?: officersCreateNestedOneWithoutReceivedMessagesInput
    inbox?: inboxCreateNestedOneWithoutMessagesInput
  }

  export type messagesUncheckedCreateWithoutSender_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateOrConnectWithoutSender_officerInput = {
    where: messagesWhereUniqueInput
    create: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput>
  }

  export type messagesCreateManySender_officerInputEnvelope = {
    data: messagesCreateManySender_officerInput | messagesCreateManySender_officerInput[]
    skipDuplicates?: boolean
  }

  export type messagesCreateWithoutRecipient_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_user?: usersCreateNestedOneWithoutSentMessagesInput
    sender_officer?: officersCreateNestedOneWithoutSentMessagesInput
    recipient_user?: usersCreateNestedOneWithoutReceivedMessagesInput
    inbox?: inboxCreateNestedOneWithoutMessagesInput
  }

  export type messagesUncheckedCreateWithoutRecipient_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateOrConnectWithoutRecipient_officerInput = {
    where: messagesWhereUniqueInput
    create: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput>
  }

  export type messagesCreateManyRecipient_officerInputEnvelope = {
    data: messagesCreateManyRecipient_officerInput | messagesCreateManyRecipient_officerInput[]
    skipDuplicates?: boolean
  }

  export type inboxCreateWithoutOfficerInput = {
    id?: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    user: usersCreateNestedOneWithoutInboxInput
    messages?: messagesCreateNestedManyWithoutInboxInput
  }

  export type inboxUncheckedCreateWithoutOfficerInput = {
    id?: string
    user_id: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    messages?: messagesUncheckedCreateNestedManyWithoutInboxInput
  }

  export type inboxCreateOrConnectWithoutOfficerInput = {
    where: inboxWhereUniqueInput
    create: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
  }

  export type patrol_unitsUpsertWithoutMembersInput = {
    update: XOR<patrol_unitsUpdateWithoutMembersInput, patrol_unitsUncheckedUpdateWithoutMembersInput>
    create: XOR<patrol_unitsCreateWithoutMembersInput, patrol_unitsUncheckedCreateWithoutMembersInput>
    where?: patrol_unitsWhereInput
  }

  export type patrol_unitsUpdateToOneWithWhereWithoutMembersInput = {
    where?: patrol_unitsWhereInput
    data: XOR<patrol_unitsUpdateWithoutMembersInput, patrol_unitsUncheckedUpdateWithoutMembersInput>
  }

  export type patrol_unitsUpdateWithoutMembersInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    location?: locationsUpdateOneRequiredWithoutPatrol_unitsNestedInput
    unit?: unitsUpdateOneRequiredWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsUncheckedUpdateWithoutMembersInput = {
    unit_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type rolesUpsertWithoutOfficersInput = {
    update: XOR<rolesUpdateWithoutOfficersInput, rolesUncheckedUpdateWithoutOfficersInput>
    create: XOR<rolesCreateWithoutOfficersInput, rolesUncheckedCreateWithoutOfficersInput>
    where?: rolesWhereInput
  }

  export type rolesUpdateToOneWithWhereWithoutOfficersInput = {
    where?: rolesWhereInput
    data: XOR<rolesUpdateWithoutOfficersInput, rolesUncheckedUpdateWithoutOfficersInput>
  }

  export type rolesUpdateWithoutOfficersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: permissionsUpdateManyWithoutRoleNestedInput
    users?: usersUpdateManyWithoutRoleNestedInput
  }

  export type rolesUncheckedUpdateWithoutOfficersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: permissionsUncheckedUpdateManyWithoutRoleNestedInput
    users?: usersUncheckedUpdateManyWithoutRoleNestedInput
  }

  export type unitsUpdateToOneWithWhereWithoutOfficersInput = {
    where?: unitsWhereInput
    data: XOR<unitsUpdateWithoutOfficersInput, unitsUncheckedUpdateWithoutOfficersInput>
  }

  export type unitsUpdateWithoutOfficersInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    patrol_units?: patrol_unitsUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUpdateManyWithoutUnitsNestedInput
    cities?: citiesUpdateOneRequiredWithoutUnitsNestedInput
    districts?: districtsUpdateOneWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateWithoutOfficersInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput
  }

  export type panic_button_logsUpsertWithWhereUniqueWithoutOfficersInput = {
    where: panic_button_logsWhereUniqueInput
    update: XOR<panic_button_logsUpdateWithoutOfficersInput, panic_button_logsUncheckedUpdateWithoutOfficersInput>
    create: XOR<panic_button_logsCreateWithoutOfficersInput, panic_button_logsUncheckedCreateWithoutOfficersInput>
  }

  export type panic_button_logsUpdateWithWhereUniqueWithoutOfficersInput = {
    where: panic_button_logsWhereUniqueInput
    data: XOR<panic_button_logsUpdateWithoutOfficersInput, panic_button_logsUncheckedUpdateWithoutOfficersInput>
  }

  export type panic_button_logsUpdateManyWithWhereWithoutOfficersInput = {
    where: panic_button_logsScalarWhereInput
    data: XOR<panic_button_logsUpdateManyMutationInput, panic_button_logsUncheckedUpdateManyWithoutOfficersInput>
  }

  export type messagesUpsertWithWhereUniqueWithoutSender_officerInput = {
    where: messagesWhereUniqueInput
    update: XOR<messagesUpdateWithoutSender_officerInput, messagesUncheckedUpdateWithoutSender_officerInput>
    create: XOR<messagesCreateWithoutSender_officerInput, messagesUncheckedCreateWithoutSender_officerInput>
  }

  export type messagesUpdateWithWhereUniqueWithoutSender_officerInput = {
    where: messagesWhereUniqueInput
    data: XOR<messagesUpdateWithoutSender_officerInput, messagesUncheckedUpdateWithoutSender_officerInput>
  }

  export type messagesUpdateManyWithWhereWithoutSender_officerInput = {
    where: messagesScalarWhereInput
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyWithoutSender_officerInput>
  }

  export type messagesUpsertWithWhereUniqueWithoutRecipient_officerInput = {
    where: messagesWhereUniqueInput
    update: XOR<messagesUpdateWithoutRecipient_officerInput, messagesUncheckedUpdateWithoutRecipient_officerInput>
    create: XOR<messagesCreateWithoutRecipient_officerInput, messagesUncheckedCreateWithoutRecipient_officerInput>
  }

  export type messagesUpdateWithWhereUniqueWithoutRecipient_officerInput = {
    where: messagesWhereUniqueInput
    data: XOR<messagesUpdateWithoutRecipient_officerInput, messagesUncheckedUpdateWithoutRecipient_officerInput>
  }

  export type messagesUpdateManyWithWhereWithoutRecipient_officerInput = {
    where: messagesScalarWhereInput
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyWithoutRecipient_officerInput>
  }

  export type inboxUpsertWithoutOfficerInput = {
    update: XOR<inboxUpdateWithoutOfficerInput, inboxUncheckedUpdateWithoutOfficerInput>
    create: XOR<inboxCreateWithoutOfficerInput, inboxUncheckedCreateWithoutOfficerInput>
    where?: inboxWhereInput
  }

  export type inboxUpdateToOneWithWhereWithoutOfficerInput = {
    where?: inboxWhereInput
    data: XOR<inboxUpdateWithoutOfficerInput, inboxUncheckedUpdateWithoutOfficerInput>
  }

  export type inboxUpdateWithoutOfficerInput = {
    id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: usersUpdateOneRequiredWithoutInboxNestedInput
    messages?: messagesUpdateManyWithoutInboxNestedInput
  }

  export type inboxUncheckedUpdateWithoutOfficerInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    messages?: messagesUncheckedUpdateManyWithoutInboxNestedInput
  }

  export type unitsUpdateToOneWithWhereWithoutUnit_statisticsInput = {
    where?: unitsWhereInput
    data: XOR<unitsUpdateWithoutUnit_statisticsInput, unitsUncheckedUpdateWithoutUnit_statisticsInput>
  }

  export type unitsUpdateWithoutUnit_statisticsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutUnitNestedInput
    cities?: citiesUpdateOneRequiredWithoutUnitsNestedInput
    districts?: districtsUpdateOneWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateWithoutUnit_statisticsInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    city_id?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUncheckedUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput
  }

  export type districtsCreateWithoutGeographicsInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersCreateNestedManyWithoutDistrictInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutGeographicsInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    district_clusters?: district_clustersUncheckedCreateNestedManyWithoutDistrictInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutGeographicsInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutGeographicsInput, districtsUncheckedCreateWithoutGeographicsInput>
  }

  export type districtsUpsertWithoutGeographicsInput = {
    update: XOR<districtsUpdateWithoutGeographicsInput, districtsUncheckedUpdateWithoutGeographicsInput>
    create: XOR<districtsCreateWithoutGeographicsInput, districtsUncheckedCreateWithoutGeographicsInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutGeographicsInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutGeographicsInput, districtsUncheckedUpdateWithoutGeographicsInput>
  }

  export type districtsUpdateWithoutGeographicsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutGeographicsInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type usersCreateWithoutSentMessagesInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutSentMessagesInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutSentMessagesInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutSentMessagesInput, usersUncheckedCreateWithoutSentMessagesInput>
  }

  export type officersCreateWithoutSentMessagesInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutSentMessagesInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutSentMessagesInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutSentMessagesInput, officersUncheckedCreateWithoutSentMessagesInput>
  }

  export type usersCreateWithoutReceivedMessagesInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutReceivedMessagesInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutReceivedMessagesInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutReceivedMessagesInput, usersUncheckedCreateWithoutReceivedMessagesInput>
  }

  export type officersCreateWithoutReceivedMessagesInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutReceivedMessagesInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutReceivedMessagesInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutReceivedMessagesInput, officersUncheckedCreateWithoutReceivedMessagesInput>
  }

  export type inboxCreateWithoutMessagesInput = {
    id?: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
    user: usersCreateNestedOneWithoutInboxInput
    officer: officersCreateNestedOneWithoutInboxInput
  }

  export type inboxUncheckedCreateWithoutMessagesInput = {
    id?: string
    user_id: string
    officer_id: string
    unread_count?: number
    last_updated?: Date | string
    created_at?: Date | string
  }

  export type inboxCreateOrConnectWithoutMessagesInput = {
    where: inboxWhereUniqueInput
    create: XOR<inboxCreateWithoutMessagesInput, inboxUncheckedCreateWithoutMessagesInput>
  }

  export type usersUpsertWithoutSentMessagesInput = {
    update: XOR<usersUpdateWithoutSentMessagesInput, usersUncheckedUpdateWithoutSentMessagesInput>
    create: XOR<usersCreateWithoutSentMessagesInput, usersUncheckedCreateWithoutSentMessagesInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutSentMessagesInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutSentMessagesInput, usersUncheckedUpdateWithoutSentMessagesInput>
  }

  export type usersUpdateWithoutSentMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutSentMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type officersUpsertWithoutSentMessagesInput = {
    update: XOR<officersUpdateWithoutSentMessagesInput, officersUncheckedUpdateWithoutSentMessagesInput>
    create: XOR<officersCreateWithoutSentMessagesInput, officersUncheckedCreateWithoutSentMessagesInput>
    where?: officersWhereInput
  }

  export type officersUpdateToOneWithWhereWithoutSentMessagesInput = {
    where?: officersWhereInput
    data: XOR<officersUpdateWithoutSentMessagesInput, officersUncheckedUpdateWithoutSentMessagesInput>
  }

  export type officersUpdateWithoutSentMessagesInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutSentMessagesInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type usersUpsertWithoutReceivedMessagesInput = {
    update: XOR<usersUpdateWithoutReceivedMessagesInput, usersUncheckedUpdateWithoutReceivedMessagesInput>
    create: XOR<usersCreateWithoutReceivedMessagesInput, usersUncheckedCreateWithoutReceivedMessagesInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutReceivedMessagesInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutReceivedMessagesInput, usersUncheckedUpdateWithoutReceivedMessagesInput>
  }

  export type usersUpdateWithoutReceivedMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutReceivedMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type officersUpsertWithoutReceivedMessagesInput = {
    update: XOR<officersUpdateWithoutReceivedMessagesInput, officersUncheckedUpdateWithoutReceivedMessagesInput>
    create: XOR<officersCreateWithoutReceivedMessagesInput, officersUncheckedCreateWithoutReceivedMessagesInput>
    where?: officersWhereInput
  }

  export type officersUpdateToOneWithWhereWithoutReceivedMessagesInput = {
    where?: officersWhereInput
    data: XOR<officersUpdateWithoutReceivedMessagesInput, officersUncheckedUpdateWithoutReceivedMessagesInput>
  }

  export type officersUpdateWithoutReceivedMessagesInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutReceivedMessagesInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type inboxUpsertWithoutMessagesInput = {
    update: XOR<inboxUpdateWithoutMessagesInput, inboxUncheckedUpdateWithoutMessagesInput>
    create: XOR<inboxCreateWithoutMessagesInput, inboxUncheckedCreateWithoutMessagesInput>
    where?: inboxWhereInput
  }

  export type inboxUpdateToOneWithWhereWithoutMessagesInput = {
    where?: inboxWhereInput
    data: XOR<inboxUpdateWithoutMessagesInput, inboxUncheckedUpdateWithoutMessagesInput>
  }

  export type inboxUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: usersUpdateOneRequiredWithoutInboxNestedInput
    officer?: officersUpdateOneRequiredWithoutInboxNestedInput
  }

  export type inboxUncheckedUpdateWithoutMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: StringFieldUpdateOperationsInput | string
    unread_count?: IntFieldUpdateOperationsInput | number
    last_updated?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type usersCreateWithoutInboxInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
  }

  export type usersUncheckedCreateWithoutInboxInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
  }

  export type usersCreateOrConnectWithoutInboxInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutInboxInput, usersUncheckedCreateWithoutInboxInput>
  }

  export type officersCreateWithoutInboxInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
  }

  export type officersUncheckedCreateWithoutInboxInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutOfficersInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
  }

  export type officersCreateOrConnectWithoutInboxInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutInboxInput, officersUncheckedCreateWithoutInboxInput>
  }

  export type messagesCreateWithoutInboxInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
    sender_user?: usersCreateNestedOneWithoutSentMessagesInput
    sender_officer?: officersCreateNestedOneWithoutSentMessagesInput
    recipient_user?: usersCreateNestedOneWithoutReceivedMessagesInput
    recipient_officer?: officersCreateNestedOneWithoutReceivedMessagesInput
  }

  export type messagesUncheckedCreateWithoutInboxInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateOrConnectWithoutInboxInput = {
    where: messagesWhereUniqueInput
    create: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput>
  }

  export type messagesCreateManyInboxInputEnvelope = {
    data: messagesCreateManyInboxInput | messagesCreateManyInboxInput[]
    skipDuplicates?: boolean
  }

  export type usersUpsertWithoutInboxInput = {
    update: XOR<usersUpdateWithoutInboxInput, usersUncheckedUpdateWithoutInboxInput>
    create: XOR<usersCreateWithoutInboxInput, usersUncheckedCreateWithoutInboxInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutInboxInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutInboxInput, usersUncheckedUpdateWithoutInboxInput>
  }

  export type usersUpdateWithoutInboxInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
  }

  export type usersUncheckedUpdateWithoutInboxInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
  }

  export type officersUpsertWithoutInboxInput = {
    update: XOR<officersUpdateWithoutInboxInput, officersUncheckedUpdateWithoutInboxInput>
    create: XOR<officersCreateWithoutInboxInput, officersUncheckedCreateWithoutInboxInput>
    where?: officersWhereInput
  }

  export type officersUpdateToOneWithWhereWithoutInboxInput = {
    where?: officersWhereInput
    data: XOR<officersUpdateWithoutInboxInput, officersUncheckedUpdateWithoutInboxInput>
  }

  export type officersUpdateWithoutInboxInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
  }

  export type officersUncheckedUpdateWithoutInboxInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
  }

  export type messagesUpsertWithWhereUniqueWithoutInboxInput = {
    where: messagesWhereUniqueInput
    update: XOR<messagesUpdateWithoutInboxInput, messagesUncheckedUpdateWithoutInboxInput>
    create: XOR<messagesCreateWithoutInboxInput, messagesUncheckedCreateWithoutInboxInput>
  }

  export type messagesUpdateWithWhereUniqueWithoutInboxInput = {
    where: messagesWhereUniqueInput
    data: XOR<messagesUpdateWithoutInboxInput, messagesUncheckedUpdateWithoutInboxInput>
  }

  export type messagesUpdateManyWithWhereWithoutInboxInput = {
    where: messagesScalarWhereInput
    data: XOR<messagesUpdateManyMutationInput, messagesUncheckedUpdateManyWithoutInboxInput>
  }

  export type incident_logsCreateWithoutPanic_button_logsInput = {
    id?: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceCreateNestedManyWithoutIncidentInput
    crime_categories: crime_categoriesCreateNestedOneWithoutIncident_logsInput
    locations: locationsCreateNestedOneWithoutIncident_logsInput
    user: usersCreateNestedOneWithoutIncident_logsInput
    timelines?: timelinesCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsUncheckedCreateWithoutPanic_button_logsInput = {
    id?: string
    user_id: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    evidence?: evidenceUncheckedCreateNestedManyWithoutIncidentInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutIncidentInput
    witnesses?: witnessesUncheckedCreateNestedManyWithoutIncidentInput
  }

  export type incident_logsCreateOrConnectWithoutPanic_button_logsInput = {
    where: incident_logsWhereUniqueInput
    create: XOR<incident_logsCreateWithoutPanic_button_logsInput, incident_logsUncheckedCreateWithoutPanic_button_logsInput>
  }

  export type officersCreateWithoutPanic_button_logsInput = {
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    patrol_units?: patrol_unitsCreateNestedOneWithoutMembersInput
    roles: rolesCreateNestedOneWithoutOfficersInput
    units?: unitsCreateNestedOneWithoutOfficersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxCreateNestedOneWithoutOfficerInput
  }

  export type officersUncheckedCreateWithoutPanic_button_logsInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_officerInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_officerInput
    inbox?: inboxUncheckedCreateNestedOneWithoutOfficerInput
  }

  export type officersCreateOrConnectWithoutPanic_button_logsInput = {
    where: officersWhereUniqueInput
    create: XOR<officersCreateWithoutPanic_button_logsInput, officersUncheckedCreateWithoutPanic_button_logsInput>
  }

  export type usersCreateWithoutPanic_button_logsInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutPanic_button_logsInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutPanic_button_logsInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutPanic_button_logsInput, usersUncheckedCreateWithoutPanic_button_logsInput>
  }

  export type incident_logsUpsertWithoutPanic_button_logsInput = {
    update: XOR<incident_logsUpdateWithoutPanic_button_logsInput, incident_logsUncheckedUpdateWithoutPanic_button_logsInput>
    create: XOR<incident_logsCreateWithoutPanic_button_logsInput, incident_logsUncheckedCreateWithoutPanic_button_logsInput>
    where?: incident_logsWhereInput
  }

  export type incident_logsUpdateToOneWithWhereWithoutPanic_button_logsInput = {
    where?: incident_logsWhereInput
    data: XOR<incident_logsUpdateWithoutPanic_button_logsInput, incident_logsUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type incident_logsUpdateWithoutPanic_button_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutPanic_button_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type officersUpsertWithoutPanic_button_logsInput = {
    update: XOR<officersUpdateWithoutPanic_button_logsInput, officersUncheckedUpdateWithoutPanic_button_logsInput>
    create: XOR<officersCreateWithoutPanic_button_logsInput, officersUncheckedCreateWithoutPanic_button_logsInput>
    where?: officersWhereInput
  }

  export type officersUpdateToOneWithWhereWithoutPanic_button_logsInput = {
    where?: officersWhereInput
    data: XOR<officersUpdateWithoutPanic_button_logsInput, officersUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type officersUpdateWithoutPanic_button_logsInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutPanic_button_logsInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type usersUpsertWithoutPanic_button_logsInput = {
    update: XOR<usersUpdateWithoutPanic_button_logsInput, usersUncheckedUpdateWithoutPanic_button_logsInput>
    create: XOR<usersCreateWithoutPanic_button_logsInput, usersUncheckedCreateWithoutPanic_button_logsInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutPanic_button_logsInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutPanic_button_logsInput, usersUncheckedUpdateWithoutPanic_button_logsInput>
  }

  export type usersUpdateWithoutPanic_button_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutPanic_button_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type locationsUpdateToOneWithWhereWithoutLocation_logsInput = {
    where?: locationsWhereInput
    data: XOR<locationsUpdateWithoutLocation_logsInput, locationsUncheckedUpdateWithoutLocation_logsInput>
  }

  export type locationsUpdateWithoutLocation_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateWithoutLocation_logsInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type districtsCreateWithoutDistrict_clustersInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsCreateNestedManyWithoutDistrictsInput
    cities: citiesCreateNestedOneWithoutDistrictsInput
    geographics?: geographicsCreateNestedManyWithoutDistrictsInput
    locations?: locationsCreateNestedManyWithoutDistrictsInput
    units?: unitsCreateNestedOneWithoutDistrictsInput
  }

  export type districtsUncheckedCreateWithoutDistrict_clustersInput = {
    id: string
    city_id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
    crimes?: crimesUncheckedCreateNestedManyWithoutDistrictsInput
    demographics?: demographicsUncheckedCreateNestedManyWithoutDistrictsInput
    geographics?: geographicsUncheckedCreateNestedManyWithoutDistrictsInput
    locations?: locationsUncheckedCreateNestedManyWithoutDistrictsInput
    units?: unitsUncheckedCreateNestedOneWithoutDistrictsInput
  }

  export type districtsCreateOrConnectWithoutDistrict_clustersInput = {
    where: districtsWhereUniqueInput
    create: XOR<districtsCreateWithoutDistrict_clustersInput, districtsUncheckedCreateWithoutDistrict_clustersInput>
  }

  export type districtsUpsertWithoutDistrict_clustersInput = {
    update: XOR<districtsUpdateWithoutDistrict_clustersInput, districtsUncheckedUpdateWithoutDistrict_clustersInput>
    create: XOR<districtsCreateWithoutDistrict_clustersInput, districtsUncheckedCreateWithoutDistrict_clustersInput>
    where?: districtsWhereInput
  }

  export type districtsUpdateToOneWithWhereWithoutDistrict_clustersInput = {
    where?: districtsWhereInput
    data: XOR<districtsUpdateWithoutDistrict_clustersInput, districtsUncheckedUpdateWithoutDistrict_clustersInput>
  }

  export type districtsUpdateWithoutDistrict_clustersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    cities?: citiesUpdateOneRequiredWithoutDistrictsNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutDistrict_clustersInput = {
    id?: StringFieldUpdateOperationsInput | string
    city_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type usersCreateWithoutTaskInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    projects?: projectsCreateNestedManyWithoutUsersInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutTaskInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    projects?: projectsUncheckedCreateNestedManyWithoutUsersInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutTaskInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutTaskInput, usersUncheckedCreateWithoutTaskInput>
  }

  export type usersUpsertWithoutTaskInput = {
    update: XOR<usersUpdateWithoutTaskInput, usersUncheckedUpdateWithoutTaskInput>
    create: XOR<usersCreateWithoutTaskInput, usersUncheckedCreateWithoutTaskInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutTaskInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutTaskInput, usersUncheckedUpdateWithoutTaskInput>
  }

  export type usersUpdateWithoutTaskInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutTaskInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type usersCreateWithoutProjectsInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsCreateNestedManyWithoutUsersInput
    profile?: profilesCreateNestedOneWithoutUsersInput
    sessions?: sessionsCreateNestedManyWithoutUserInput
    timelines?: timelinesCreateNestedManyWithoutUserInput
    role: rolesCreateNestedOneWithoutUsersInput
    task?: taskCreateNestedManyWithoutUserInput
    sentMessages?: messagesCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesCreateNestedManyWithoutRecipient_userInput
    inbox?: inboxCreateNestedOneWithoutUserInput
  }

  export type usersUncheckedCreateWithoutProjectsInput = {
    id?: string
    roles_id: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    events?: eventsUncheckedCreateNestedManyWithoutUsersInput
    incident_logs?: incident_logsUncheckedCreateNestedManyWithoutUserInput
    panic_button_logs?: panic_button_logsUncheckedCreateNestedManyWithoutUsersInput
    profile?: profilesUncheckedCreateNestedOneWithoutUsersInput
    sessions?: sessionsUncheckedCreateNestedManyWithoutUserInput
    timelines?: timelinesUncheckedCreateNestedManyWithoutUserInput
    task?: taskUncheckedCreateNestedManyWithoutUserInput
    sentMessages?: messagesUncheckedCreateNestedManyWithoutSender_userInput
    receivedMessages?: messagesUncheckedCreateNestedManyWithoutRecipient_userInput
    inbox?: inboxUncheckedCreateNestedOneWithoutUserInput
  }

  export type usersCreateOrConnectWithoutProjectsInput = {
    where: usersWhereUniqueInput
    create: XOR<usersCreateWithoutProjectsInput, usersUncheckedCreateWithoutProjectsInput>
  }

  export type datasetsCreateWithoutProjectsInput = {
    id?: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    analyses?: analysesCreateNestedManyWithoutDatasetsInput
  }

  export type datasetsUncheckedCreateWithoutProjectsInput = {
    id?: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    analyses?: analysesUncheckedCreateNestedManyWithoutDatasetsInput
  }

  export type datasetsCreateOrConnectWithoutProjectsInput = {
    where: datasetsWhereUniqueInput
    create: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput>
  }

  export type datasetsCreateManyProjectsInputEnvelope = {
    data: datasetsCreateManyProjectsInput | datasetsCreateManyProjectsInput[]
    skipDuplicates?: boolean
  }

  export type analysesCreateWithoutProjectsInput = {
    id?: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    datasets: datasetsCreateNestedOneWithoutAnalysesInput
    clusters?: clustersCreateNestedManyWithoutAnalysesInput
  }

  export type analysesUncheckedCreateWithoutProjectsInput = {
    id?: string
    dataset_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    clusters?: clustersUncheckedCreateNestedManyWithoutAnalysesInput
  }

  export type analysesCreateOrConnectWithoutProjectsInput = {
    where: analysesWhereUniqueInput
    create: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput>
  }

  export type analysesCreateManyProjectsInputEnvelope = {
    data: analysesCreateManyProjectsInput | analysesCreateManyProjectsInput[]
    skipDuplicates?: boolean
  }

  export type usersUpsertWithoutProjectsInput = {
    update: XOR<usersUpdateWithoutProjectsInput, usersUncheckedUpdateWithoutProjectsInput>
    create: XOR<usersCreateWithoutProjectsInput, usersUncheckedCreateWithoutProjectsInput>
    where?: usersWhereInput
  }

  export type usersUpdateToOneWithWhereWithoutProjectsInput = {
    where?: usersWhereInput
    data: XOR<usersUpdateWithoutProjectsInput, usersUncheckedUpdateWithoutProjectsInput>
  }

  export type usersUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    role?: rolesUpdateOneRequiredWithoutUsersNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    roles_id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type datasetsUpsertWithWhereUniqueWithoutProjectsInput = {
    where: datasetsWhereUniqueInput
    update: XOR<datasetsUpdateWithoutProjectsInput, datasetsUncheckedUpdateWithoutProjectsInput>
    create: XOR<datasetsCreateWithoutProjectsInput, datasetsUncheckedCreateWithoutProjectsInput>
  }

  export type datasetsUpdateWithWhereUniqueWithoutProjectsInput = {
    where: datasetsWhereUniqueInput
    data: XOR<datasetsUpdateWithoutProjectsInput, datasetsUncheckedUpdateWithoutProjectsInput>
  }

  export type datasetsUpdateManyWithWhereWithoutProjectsInput = {
    where: datasetsScalarWhereInput
    data: XOR<datasetsUpdateManyMutationInput, datasetsUncheckedUpdateManyWithoutProjectsInput>
  }

  export type datasetsScalarWhereInput = {
    AND?: datasetsScalarWhereInput | datasetsScalarWhereInput[]
    OR?: datasetsScalarWhereInput[]
    NOT?: datasetsScalarWhereInput | datasetsScalarWhereInput[]
    id?: UuidFilter<"datasets"> | string
    project_id?: UuidFilter<"datasets"> | string
    filename?: StringFilter<"datasets"> | string
    original_name?: StringFilter<"datasets"> | string
    file_size?: IntFilter<"datasets"> | number
    columns?: JsonFilter<"datasets">
    row_count?: IntFilter<"datasets"> | number
    metadata?: JsonNullableFilter<"datasets">
    created_at?: DateTimeFilter<"datasets"> | Date | string
  }

  export type analysesUpsertWithWhereUniqueWithoutProjectsInput = {
    where: analysesWhereUniqueInput
    update: XOR<analysesUpdateWithoutProjectsInput, analysesUncheckedUpdateWithoutProjectsInput>
    create: XOR<analysesCreateWithoutProjectsInput, analysesUncheckedCreateWithoutProjectsInput>
  }

  export type analysesUpdateWithWhereUniqueWithoutProjectsInput = {
    where: analysesWhereUniqueInput
    data: XOR<analysesUpdateWithoutProjectsInput, analysesUncheckedUpdateWithoutProjectsInput>
  }

  export type analysesUpdateManyWithWhereWithoutProjectsInput = {
    where: analysesScalarWhereInput
    data: XOR<analysesUpdateManyMutationInput, analysesUncheckedUpdateManyWithoutProjectsInput>
  }

  export type analysesScalarWhereInput = {
    AND?: analysesScalarWhereInput | analysesScalarWhereInput[]
    OR?: analysesScalarWhereInput[]
    NOT?: analysesScalarWhereInput | analysesScalarWhereInput[]
    id?: UuidFilter<"analyses"> | string
    project_id?: UuidFilter<"analyses"> | string
    dataset_id?: UuidFilter<"analyses"> | string
    name?: StringFilter<"analyses"> | string
    config?: JsonFilter<"analyses">
    results?: JsonNullableFilter<"analyses">
    status?: StringFilter<"analyses"> | string
    created_at?: DateTimeFilter<"analyses"> | Date | string
    updated_at?: DateTimeFilter<"analyses"> | Date | string
  }

  export type projectsCreateWithoutDatasetsInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    users: usersCreateNestedOneWithoutProjectsInput
    analyses?: analysesCreateNestedManyWithoutProjectsInput
  }

  export type projectsUncheckedCreateWithoutDatasetsInput = {
    id?: string
    name: string
    description?: string | null
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
    analyses?: analysesUncheckedCreateNestedManyWithoutProjectsInput
  }

  export type projectsCreateOrConnectWithoutDatasetsInput = {
    where: projectsWhereUniqueInput
    create: XOR<projectsCreateWithoutDatasetsInput, projectsUncheckedCreateWithoutDatasetsInput>
  }

  export type analysesCreateWithoutDatasetsInput = {
    id?: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    projects: projectsCreateNestedOneWithoutAnalysesInput
    clusters?: clustersCreateNestedManyWithoutAnalysesInput
  }

  export type analysesUncheckedCreateWithoutDatasetsInput = {
    id?: string
    project_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    clusters?: clustersUncheckedCreateNestedManyWithoutAnalysesInput
  }

  export type analysesCreateOrConnectWithoutDatasetsInput = {
    where: analysesWhereUniqueInput
    create: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput>
  }

  export type analysesCreateManyDatasetsInputEnvelope = {
    data: analysesCreateManyDatasetsInput | analysesCreateManyDatasetsInput[]
    skipDuplicates?: boolean
  }

  export type projectsUpsertWithoutDatasetsInput = {
    update: XOR<projectsUpdateWithoutDatasetsInput, projectsUncheckedUpdateWithoutDatasetsInput>
    create: XOR<projectsCreateWithoutDatasetsInput, projectsUncheckedCreateWithoutDatasetsInput>
    where?: projectsWhereInput
  }

  export type projectsUpdateToOneWithWhereWithoutDatasetsInput = {
    where?: projectsWhereInput
    data: XOR<projectsUpdateWithoutDatasetsInput, projectsUncheckedUpdateWithoutDatasetsInput>
  }

  export type projectsUpdateWithoutDatasetsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutProjectsNestedInput
    analyses?: analysesUpdateManyWithoutProjectsNestedInput
  }

  export type projectsUncheckedUpdateWithoutDatasetsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: analysesUncheckedUpdateManyWithoutProjectsNestedInput
  }

  export type analysesUpsertWithWhereUniqueWithoutDatasetsInput = {
    where: analysesWhereUniqueInput
    update: XOR<analysesUpdateWithoutDatasetsInput, analysesUncheckedUpdateWithoutDatasetsInput>
    create: XOR<analysesCreateWithoutDatasetsInput, analysesUncheckedCreateWithoutDatasetsInput>
  }

  export type analysesUpdateWithWhereUniqueWithoutDatasetsInput = {
    where: analysesWhereUniqueInput
    data: XOR<analysesUpdateWithoutDatasetsInput, analysesUncheckedUpdateWithoutDatasetsInput>
  }

  export type analysesUpdateManyWithWhereWithoutDatasetsInput = {
    where: analysesScalarWhereInput
    data: XOR<analysesUpdateManyMutationInput, analysesUncheckedUpdateManyWithoutDatasetsInput>
  }

  export type projectsCreateWithoutAnalysesInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
    users: usersCreateNestedOneWithoutProjectsInput
    datasets?: datasetsCreateNestedManyWithoutProjectsInput
  }

  export type projectsUncheckedCreateWithoutAnalysesInput = {
    id?: string
    name: string
    description?: string | null
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
    datasets?: datasetsUncheckedCreateNestedManyWithoutProjectsInput
  }

  export type projectsCreateOrConnectWithoutAnalysesInput = {
    where: projectsWhereUniqueInput
    create: XOR<projectsCreateWithoutAnalysesInput, projectsUncheckedCreateWithoutAnalysesInput>
  }

  export type datasetsCreateWithoutAnalysesInput = {
    id?: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    projects: projectsCreateNestedOneWithoutDatasetsInput
  }

  export type datasetsUncheckedCreateWithoutAnalysesInput = {
    id?: string
    project_id: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
  }

  export type datasetsCreateOrConnectWithoutAnalysesInput = {
    where: datasetsWhereUniqueInput
    create: XOR<datasetsCreateWithoutAnalysesInput, datasetsUncheckedCreateWithoutAnalysesInput>
  }

  export type clustersCreateWithoutAnalysesInput = {
    id?: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUncheckedCreateWithoutAnalysesInput = {
    id?: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersCreateOrConnectWithoutAnalysesInput = {
    where: clustersWhereUniqueInput
    create: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput>
  }

  export type clustersCreateManyAnalysesInputEnvelope = {
    data: clustersCreateManyAnalysesInput | clustersCreateManyAnalysesInput[]
    skipDuplicates?: boolean
  }

  export type projectsUpsertWithoutAnalysesInput = {
    update: XOR<projectsUpdateWithoutAnalysesInput, projectsUncheckedUpdateWithoutAnalysesInput>
    create: XOR<projectsCreateWithoutAnalysesInput, projectsUncheckedCreateWithoutAnalysesInput>
    where?: projectsWhereInput
  }

  export type projectsUpdateToOneWithWhereWithoutAnalysesInput = {
    where?: projectsWhereInput
    data: XOR<projectsUpdateWithoutAnalysesInput, projectsUncheckedUpdateWithoutAnalysesInput>
  }

  export type projectsUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: usersUpdateOneRequiredWithoutProjectsNestedInput
    datasets?: datasetsUpdateManyWithoutProjectsNestedInput
  }

  export type projectsUncheckedUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    datasets?: datasetsUncheckedUpdateManyWithoutProjectsNestedInput
  }

  export type datasetsUpsertWithoutAnalysesInput = {
    update: XOR<datasetsUpdateWithoutAnalysesInput, datasetsUncheckedUpdateWithoutAnalysesInput>
    create: XOR<datasetsCreateWithoutAnalysesInput, datasetsUncheckedCreateWithoutAnalysesInput>
    where?: datasetsWhereInput
  }

  export type datasetsUpdateToOneWithWhereWithoutAnalysesInput = {
    where?: datasetsWhereInput
    data: XOR<datasetsUpdateWithoutAnalysesInput, datasetsUncheckedUpdateWithoutAnalysesInput>
  }

  export type datasetsUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    projects?: projectsUpdateOneRequiredWithoutDatasetsNestedInput
  }

  export type datasetsUncheckedUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type clustersUpsertWithWhereUniqueWithoutAnalysesInput = {
    where: clustersWhereUniqueInput
    update: XOR<clustersUpdateWithoutAnalysesInput, clustersUncheckedUpdateWithoutAnalysesInput>
    create: XOR<clustersCreateWithoutAnalysesInput, clustersUncheckedCreateWithoutAnalysesInput>
  }

  export type clustersUpdateWithWhereUniqueWithoutAnalysesInput = {
    where: clustersWhereUniqueInput
    data: XOR<clustersUpdateWithoutAnalysesInput, clustersUncheckedUpdateWithoutAnalysesInput>
  }

  export type clustersUpdateManyWithWhereWithoutAnalysesInput = {
    where: clustersScalarWhereInput
    data: XOR<clustersUpdateManyMutationInput, clustersUncheckedUpdateManyWithoutAnalysesInput>
  }

  export type clustersScalarWhereInput = {
    AND?: clustersScalarWhereInput | clustersScalarWhereInput[]
    OR?: clustersScalarWhereInput[]
    NOT?: clustersScalarWhereInput | clustersScalarWhereInput[]
    id?: UuidFilter<"clusters"> | string
    analysis_id?: UuidFilter<"clusters"> | string
    cluster_id?: IntFilter<"clusters"> | number
    center_data?: JsonFilter<"clusters">
    point_count?: IntFilter<"clusters"> | number
    characteristics?: JsonNullableFilter<"clusters">
  }

  export type analysesCreateWithoutClustersInput = {
    id?: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
    projects: projectsCreateNestedOneWithoutAnalysesInput
    datasets: datasetsCreateNestedOneWithoutAnalysesInput
  }

  export type analysesUncheckedCreateWithoutClustersInput = {
    id?: string
    project_id: string
    dataset_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type analysesCreateOrConnectWithoutClustersInput = {
    where: analysesWhereUniqueInput
    create: XOR<analysesCreateWithoutClustersInput, analysesUncheckedCreateWithoutClustersInput>
  }

  export type analysesUpsertWithoutClustersInput = {
    update: XOR<analysesUpdateWithoutClustersInput, analysesUncheckedUpdateWithoutClustersInput>
    create: XOR<analysesCreateWithoutClustersInput, analysesUncheckedCreateWithoutClustersInput>
    where?: analysesWhereInput
  }

  export type analysesUpdateToOneWithWhereWithoutClustersInput = {
    where?: analysesWhereInput
    data: XOR<analysesUpdateWithoutClustersInput, analysesUncheckedUpdateWithoutClustersInput>
  }

  export type analysesUpdateWithoutClustersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    projects?: projectsUpdateOneRequiredWithoutAnalysesNestedInput
    datasets?: datasetsUpdateOneRequiredWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateWithoutClustersInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    dataset_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type eventsCreateManyUsersInput = {
    id?: string
    name: string
    description?: string | null
    code?: string
    created_at?: Date | string
  }

  export type incident_logsCreateManyUserInput = {
    id?: string
    location_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type panic_button_logsCreateManyUsersInput = {
    id?: string
    officer_id?: string | null
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type sessionsCreateManyUserInput = {
    id?: string
    event_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type timelinesCreateManyUserInput = {
    id?: string
    incident_logs_id?: string | null
    crime_incidents_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type taskCreateManyUserInput = {
    id?: string
    code: string
    title?: string | null
    status?: $Enums.task_status
    label?: $Enums.task_label
    priority?: $Enums.task_priority
    estimated_hours?: number
    archived?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type messagesCreateManySender_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateManyRecipient_userInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type projectsCreateManyUsersInput = {
    id?: string
    name: string
    description?: string | null
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type eventsUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    locations?: locationsUpdateManyWithoutEventNestedInput
    sessions?: sessionsUpdateManyWithoutEventNestedInput
  }

  export type eventsUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    locations?: locationsUncheckedUpdateManyWithoutEventNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutEventNestedInput
  }

  export type eventsUncheckedUpdateManyWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    code?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type incident_logsUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type panic_button_logsUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    incidents?: incident_logsUpdateOneRequiredWithoutPanic_button_logsNestedInput
    officers?: officersUpdateOneWithoutPanic_button_logsNestedInput
  }

  export type panic_button_logsUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsUncheckedUpdateManyWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    event?: eventsUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type sessionsUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type timelinesUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_incidents?: crime_incidentsUpdateOneWithoutTimelinesNestedInput
    incident?: incident_logsUpdateOneWithoutTimelinesNestedInput
  }

  export type timelinesUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type taskUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type taskUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type taskUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumtask_statusFieldUpdateOperationsInput | $Enums.task_status
    label?: Enumtask_labelFieldUpdateOperationsInput | $Enums.task_label
    priority?: Enumtask_priorityFieldUpdateOperationsInput | $Enums.task_priority
    estimated_hours?: FloatFieldUpdateOperationsInput | number
    archived?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type messagesUpdateWithoutSender_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_officer?: officersUpdateOneWithoutSentMessagesNestedInput
    recipient_user?: usersUpdateOneWithoutReceivedMessagesNestedInput
    recipient_officer?: officersUpdateOneWithoutReceivedMessagesNestedInput
    inbox?: inboxUpdateOneWithoutMessagesNestedInput
  }

  export type messagesUncheckedUpdateWithoutSender_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyWithoutSender_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUpdateWithoutRecipient_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_user?: usersUpdateOneWithoutSentMessagesNestedInput
    sender_officer?: officersUpdateOneWithoutSentMessagesNestedInput
    recipient_officer?: officersUpdateOneWithoutReceivedMessagesNestedInput
    inbox?: inboxUpdateOneWithoutMessagesNestedInput
  }

  export type messagesUncheckedUpdateWithoutRecipient_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyWithoutRecipient_userInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type projectsUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    datasets?: datasetsUpdateManyWithoutProjectsNestedInput
    analyses?: analysesUpdateManyWithoutProjectsNestedInput
  }

  export type projectsUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    datasets?: datasetsUncheckedUpdateManyWithoutProjectsNestedInput
    analyses?: analysesUncheckedUpdateManyWithoutProjectsNestedInput
  }

  export type projectsUncheckedUpdateManyWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type officersCreateManyRolesInput = {
    unit_id?: string | null
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
  }

  export type permissionsCreateManyRoleInput = {
    id?: string
    action: string
    resource_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type usersCreateManyRoleInput = {
    id?: string
    email: string
    phone?: string | null
    encrypted_password?: string | null
    invited_at?: Date | string | null
    confirmed_at?: Date | string | null
    email_confirmed_at?: Date | string | null
    recovery_sent_at?: Date | string | null
    last_sign_in_at?: Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
    banned_until?: Date | string | null
    is_anonymous?: boolean
    banned_reason?: string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
  }

  export type officersUpdateWithoutRolesInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutRolesInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateManyWithoutRolesInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type permissionsUpdateWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    resource?: resourcesUpdateOneRequiredWithoutPermissionsNestedInput
  }

  export type permissionsUncheckedUpdateWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    resource_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsUncheckedUpdateManyWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    resource_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type usersUpdateWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutUsersNestedInput
    profile?: profilesUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUpdateManyWithoutUserNestedInput
    timelines?: timelinesUpdateManyWithoutUserNestedInput
    task?: taskUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUpdateManyWithoutUsersNestedInput
    inbox?: inboxUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    events?: eventsUncheckedUpdateManyWithoutUsersNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutUserNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutUsersNestedInput
    profile?: profilesUncheckedUpdateOneWithoutUsersNestedInput
    sessions?: sessionsUncheckedUpdateManyWithoutUserNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutUserNestedInput
    task?: taskUncheckedUpdateManyWithoutUserNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_userNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_userNestedInput
    projects?: projectsUncheckedUpdateManyWithoutUsersNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutUserNestedInput
  }

  export type usersUncheckedUpdateManyWithoutRoleInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    encrypted_password?: NullableStringFieldUpdateOperationsInput | string | null
    invited_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    email_confirmed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    recovery_sent_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    last_sign_in_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    app_metadata?: NullableJsonNullValueInput | InputJsonValue
    user_metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_anonymous?: BoolFieldUpdateOperationsInput | boolean
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
  }

  export type sessionsCreateManyEventInput = {
    id?: string
    user_id: string
    status?: $Enums.session_status
    created_at?: Date | string
  }

  export type locationsUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    districts?: districtsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateManyWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    district_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type sessionsUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: usersUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type sessionsUncheckedUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type sessionsUncheckedUpdateManyWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    status?: Enumsession_statusFieldUpdateOperationsInput | $Enums.session_status
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsCreateManyResourceInput = {
    id?: string
    action: string
    role_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type permissionsUpdateWithoutResourceInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    role?: rolesUpdateOneRequiredWithoutPermissionsNestedInput
  }

  export type permissionsUncheckedUpdateWithoutResourceInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    role_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type permissionsUncheckedUpdateManyWithoutResourceInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    role_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type districtsCreateManyCitiesInput = {
    id: string
    name: string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type districtsUpdateWithoutCitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUpdateManyWithoutDistrictsNestedInput
    units?: unitsUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateWithoutCitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crimes?: crimesUncheckedUpdateManyWithoutDistrictsNestedInput
    demographics?: demographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    district_clusters?: district_clustersUncheckedUpdateManyWithoutDistrictNestedInput
    geographics?: geographicsUncheckedUpdateManyWithoutDistrictsNestedInput
    locations?: locationsUncheckedUpdateManyWithoutDistrictsNestedInput
    units?: unitsUncheckedUpdateOneWithoutDistrictsNestedInput
  }

  export type districtsUncheckedUpdateManyWithoutCitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unitsUpdateWithoutCitiesInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUpdateManyWithoutUnitsNestedInput
    districts?: districtsUpdateOneWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateWithoutCitiesInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    officers?: officersUncheckedUpdateManyWithoutUnitsNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutUnitNestedInput
    unit_statistics?: unit_statisticsUncheckedUpdateManyWithoutUnitsNestedInput
  }

  export type unitsUncheckedUpdateManyWithoutCitiesInput = {
    code_unit?: StringFieldUpdateOperationsInput | string
    district_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: Enumunit_typeFieldUpdateOperationsInput | $Enums.unit_type
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    phone?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type evidenceCreateManyCrime_incidentsInput = {
    incident_logs_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type timelinesCreateManyCrime_incidentsInput = {
    id?: string
    incident_logs_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesCreateManyCrime_incidentsInput = {
    id?: string
    incident_logs_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type evidenceUpdateWithoutCrime_incidentsInput = {
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    incident?: incident_logsUpdateOneWithoutEvidenceNestedInput
  }

  export type evidenceUncheckedUpdateWithoutCrime_incidentsInput = {
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type evidenceUncheckedUpdateManyWithoutCrime_incidentsInput = {
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type timelinesUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    incident?: incident_logsUpdateOneWithoutTimelinesNestedInput
    user?: usersUpdateOneWithoutTimelinesNestedInput
  }

  export type timelinesUncheckedUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesUncheckedUpdateManyWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    incident?: incident_logsUpdateOneWithoutWitnessesNestedInput
  }

  export type witnessesUncheckedUpdateWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesUncheckedUpdateManyWithoutCrime_incidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type crime_incidentsCreateManyCrime_categoriesInput = {
    id: string
    crime_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
  }

  export type incident_logsCreateManyCrime_categoriesInput = {
    id?: string
    user_id: string
    location_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type crime_incidentsUpdateWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateManyWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type incident_logsUpdateWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    locations?: locationsUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateManyWithoutCrime_categoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type crime_incidentsCreateManyCrimesInput = {
    id: string
    crime_category_id: string
    location_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
  }

  export type crime_incidentsUpdateWithoutCrimesInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    locations?: locationsUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutCrimesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateManyWithoutCrimesInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    location_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type crimesCreateManyDistrictsInput = {
    id: string
    created_at?: Date | string | null
    level?: $Enums.crime_rates
    method?: string | null
    month?: number | null
    number_of_crime?: number
    score?: number
    updated_at?: Date | string | null
    year?: number | null
    source_type?: string | null
    crime_cleared?: number
    avg_crime?: number
  }

  export type demographicsCreateManyDistrictsInput = {
    id?: string
    population: number
    number_of_unemployed: number
    population_density: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type district_clustersCreateManyDistrictInput = {
    id?: string
    year: number
    month?: number | null
    risk_level?: $Enums.crime_rates
    total_crimes?: number
    population_density?: number
    unemployment_rate?: number
    crime_score?: number
    density_score?: number
    unemployment_score?: number
    cluster_score?: number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: number
    last_update_type?: string
    update_count?: number
    needs_recompute?: boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type crimesUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
    crime_incidents?: crime_incidentsUpdateManyWithoutCrimesNestedInput
  }

  export type crimesUncheckedUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutCrimesNestedInput
  }

  export type crimesUncheckedUpdateManyWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    method?: NullableStringFieldUpdateOperationsInput | string | null
    month?: NullableIntFieldUpdateOperationsInput | number | null
    number_of_crime?: IntFieldUpdateOperationsInput | number
    score?: FloatFieldUpdateOperationsInput | number
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
    source_type?: NullableStringFieldUpdateOperationsInput | string | null
    crime_cleared?: IntFieldUpdateOperationsInput | number
    avg_crime?: FloatFieldUpdateOperationsInput | number
  }

  export type demographicsUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type demographicsUncheckedUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type demographicsUncheckedUpdateManyWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    population?: IntFieldUpdateOperationsInput | number
    number_of_unemployed?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type district_clustersUpdateWithoutDistrictInput = {
    id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type district_clustersUncheckedUpdateWithoutDistrictInput = {
    id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type district_clustersUncheckedUpdateManyWithoutDistrictInput = {
    id?: StringFieldUpdateOperationsInput | string
    year?: IntFieldUpdateOperationsInput | number
    month?: NullableIntFieldUpdateOperationsInput | number | null
    risk_level?: Enumcrime_ratesFieldUpdateOperationsInput | $Enums.crime_rates
    total_crimes?: IntFieldUpdateOperationsInput | number
    population_density?: FloatFieldUpdateOperationsInput | number
    unemployment_rate?: FloatFieldUpdateOperationsInput | number
    crime_score?: FloatFieldUpdateOperationsInput | number
    density_score?: FloatFieldUpdateOperationsInput | number
    unemployment_score?: FloatFieldUpdateOperationsInput | number
    cluster_score?: FloatFieldUpdateOperationsInput | number
    centroid_features?: NullableJsonNullValueInput | InputJsonValue
    member_count?: IntFieldUpdateOperationsInput | number
    last_update_type?: StringFieldUpdateOperationsInput | string
    update_count?: IntFieldUpdateOperationsInput | number
    needs_recompute?: BoolFieldUpdateOperationsInput | boolean
    incidents_data?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type geographicsUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type geographicsUncheckedUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type geographicsUncheckedUpdateManyWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    longitude?: FloatFieldUpdateOperationsInput | number
    latitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    year?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type locationsUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUpdateManyWithoutLocationNestedInput
    event?: eventsUpdateOneRequiredWithoutLocationsNestedInput
    patrol_units?: patrol_unitsUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
    crime_incidents?: crime_incidentsUncheckedUpdateManyWithoutLocationsNestedInput
    incident_logs?: incident_logsUncheckedUpdateManyWithoutLocationsNestedInput
    location_logs?: location_logsUncheckedUpdateManyWithoutLocationNestedInput
    patrol_units?: patrol_unitsUncheckedUpdateManyWithoutLocationNestedInput
  }

  export type locationsUncheckedUpdateManyWithoutDistrictsInput = {
    id?: StringFieldUpdateOperationsInput | string
    event_id?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableStringFieldUpdateOperationsInput | string | null
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    land_area?: NullableFloatFieldUpdateOperationsInput | number | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    distance_to_unit?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type crime_incidentsUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    crimes?: crimesUpdateOneRequiredWithoutCrime_incidentsNestedInput
    evidences?: evidenceUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsUncheckedUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    evidences?: evidenceUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutCrime_incidentsNestedInput
  }

  export type crime_incidentsCreateManyLocationsInput = {
    id: string
    crime_id: string
    crime_category_id: string
    description: string
    victim_count: number
    status?: $Enums.crime_status | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    timestamp?: Date | string
  }

  export type crime_incidentsUncheckedUpdateManyWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_id?: StringFieldUpdateOperationsInput | string
    crime_category_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    victim_count?: IntFieldUpdateOperationsInput | number
    status?: NullableEnumcrime_statusFieldUpdateOperationsInput | $Enums.crime_status | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type incident_logsUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUpdateManyWithoutIncidentNestedInput
    crime_categories?: crime_categoriesUpdateOneRequiredWithoutIncident_logsNestedInput
    user?: usersUpdateOneRequiredWithoutIncident_logsNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsUncheckedUpdateWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    evidence?: evidenceUncheckedUpdateManyWithoutIncidentNestedInput
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutIncidentsNestedInput
    timelines?: timelinesUncheckedUpdateManyWithoutIncidentNestedInput
    witnesses?: witnessesUncheckedUpdateManyWithoutIncidentNestedInput
  }

  export type incident_logsCreateManyLocationsInput = {
    id?: string
    user_id: string
    category_id: string
    description?: string | null
    source?: string | null
    time?: Date | string
    verified?: boolean | null
    severity?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type incident_logsUncheckedUpdateManyWithoutLocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    source?: NullableStringFieldUpdateOperationsInput | string | null
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    verified?: NullableBoolFieldUpdateOperationsInput | boolean | null
    severity?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type location_logsUpdateWithoutLocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type location_logsUncheckedUpdateWithoutLocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type location_logsUncheckedUpdateManyWithoutLocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    latitude?: FloatFieldUpdateOperationsInput | number
    longitude?: FloatFieldUpdateOperationsInput | number
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type patrol_unitsUpdateWithoutLocationInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUpdateManyWithoutPatrol_unitsNestedInput
    unit?: unitsUpdateOneRequiredWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsUncheckedUpdateWithoutLocationInput = {
    unit_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUncheckedUpdateManyWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsCreateManyLocationInput = {
    unit_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
  }

  export type patrol_unitsUncheckedUpdateManyWithoutLocationInput = {
    unit_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type evidenceCreateManyIncidentInput = {
    crime_incidents_id?: string | null
    type: string
    url: string
    status?: string | null
    uploaded_at?: Date | string | null
    updated_at?: Date | string | null
    caption?: string | null
    description?: string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id: string
  }

  export type panic_button_logsCreateManyIncidentsInput = {
    id?: string
    user_id: string
    officer_id?: string | null
    timestamp?: Date | string
  }

  export type timelinesCreateManyIncidentInput = {
    id?: string
    crime_incidents_id?: string | null
    user_id?: string | null
    title?: string | null
    description?: string | null
    timestamp?: Date | string
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type witnessesCreateManyIncidentInput = {
    id?: string
    crime_incidents_id?: string | null
    name?: string | null
    contact_info?: string | null
    statement?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type evidenceUpdateWithoutIncidentInput = {
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents?: crime_incidentsUpdateOneWithoutEvidencesNestedInput
  }

  export type evidenceUncheckedUpdateWithoutIncidentInput = {
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type evidenceUncheckedUpdateManyWithoutIncidentInput = {
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    type?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    uploaded_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    caption?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    metadata?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
  }

  export type panic_button_logsUpdateWithoutIncidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    officers?: officersUpdateOneWithoutPanic_button_logsNestedInput
    users?: usersUpdateOneRequiredWithoutPanic_button_logsNestedInput
  }

  export type panic_button_logsUncheckedUpdateWithoutIncidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsUncheckedUpdateManyWithoutIncidentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type timelinesUpdateWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_incidents?: crime_incidentsUpdateOneWithoutTimelinesNestedInput
    user?: usersUpdateOneWithoutTimelinesNestedInput
  }

  export type timelinesUncheckedUpdateWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type timelinesUncheckedUpdateManyWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    title?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesUpdateWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    crime_incidents?: crime_incidentsUpdateOneWithoutWitnessesNestedInput
  }

  export type witnessesUncheckedUpdateWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type witnessesUncheckedUpdateManyWithoutIncidentInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_incidents_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    contact_info?: NullableStringFieldUpdateOperationsInput | string | null
    statement?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type officersUpdateWithoutUnitsInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_units?: patrol_unitsUpdateOneWithoutMembersNestedInput
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutUnitsInput = {
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type officersCreateManyUnitsInput = {
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    patrol_unit_id?: string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
  }

  export type officersUncheckedUpdateManyWithoutUnitsInput = {
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    patrol_unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type patrol_unitsUpdateWithoutUnitInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUpdateManyWithoutPatrol_unitsNestedInput
    location?: locationsUpdateOneRequiredWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsUncheckedUpdateWithoutUnitInput = {
    location_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    members?: officersUncheckedUpdateManyWithoutPatrol_unitsNestedInput
  }

  export type patrol_unitsCreateManyUnitInput = {
    location_id: string
    name: string
    type: string
    status: string
    radius: number
    created_at?: Date | string
    id: string
    category?: $Enums.patrol_unit_category | null
    member_count?: number | null
    updated_at?: Date | string | null
  }

  export type patrol_unitsUncheckedUpdateManyWithoutUnitInput = {
    location_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    radius?: FloatFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    category?: NullableEnumpatrol_unit_categoryFieldUpdateOperationsInput | $Enums.patrol_unit_category | null
    member_count?: NullableIntFieldUpdateOperationsInput | number | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unit_statisticsUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unit_statisticsUncheckedUpdateWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type unit_statisticsCreateManyUnitsInput = {
    id?: string
    crime_total: number
    crime_cleared: number
    percentage?: number | null
    pending?: number | null
    month: number
    year: number
    created_at?: Date | string | null
    updated_at?: Date | string | null
  }

  export type unit_statisticsUncheckedUpdateManyWithoutUnitsInput = {
    id?: StringFieldUpdateOperationsInput | string
    crime_total?: IntFieldUpdateOperationsInput | number
    crime_cleared?: IntFieldUpdateOperationsInput | number
    percentage?: NullableFloatFieldUpdateOperationsInput | number | null
    pending?: NullableIntFieldUpdateOperationsInput | number | null
    month?: IntFieldUpdateOperationsInput | number
    year?: IntFieldUpdateOperationsInput | number
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type officersCreateManyPatrol_unitsInput = {
    unit_id?: string | null
    role_id: string
    nrp?: string | null
    name: string
    rank?: string | null
    position?: string | null
    phone?: string | null
    email?: string | null
    avatar?: string | null
    valid_until?: Date | string | null
    qr_code?: string | null
    created_at?: Date | string | null
    updated_at?: Date | string | null
    id?: string
    banned_reason?: string | null
    banned_until?: Date | string | null
    is_banned?: boolean
    panic_strike?: number
    spoofing_attempts?: number
    place_of_birth?: string | null
    date_of_birth?: Date | string | null
  }

  export type officersUpdateWithoutPatrol_unitsInput = {
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    roles?: rolesUpdateOneRequiredWithoutOfficersNestedInput
    units?: unitsUpdateOneWithoutOfficersNestedInput
    panic_button_logs?: panic_button_logsUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateWithoutPatrol_unitsInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    panic_button_logs?: panic_button_logsUncheckedUpdateManyWithoutOfficersNestedInput
    sentMessages?: messagesUncheckedUpdateManyWithoutSender_officerNestedInput
    receivedMessages?: messagesUncheckedUpdateManyWithoutRecipient_officerNestedInput
    inbox?: inboxUncheckedUpdateOneWithoutOfficerNestedInput
  }

  export type officersUncheckedUpdateManyWithoutPatrol_unitsInput = {
    unit_id?: NullableStringFieldUpdateOperationsInput | string | null
    role_id?: StringFieldUpdateOperationsInput | string
    nrp?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    rank?: NullableStringFieldUpdateOperationsInput | string | null
    position?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    avatar?: NullableStringFieldUpdateOperationsInput | string | null
    valid_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    qr_code?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updated_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    id?: StringFieldUpdateOperationsInput | string
    banned_reason?: NullableStringFieldUpdateOperationsInput | string | null
    banned_until?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    is_banned?: BoolFieldUpdateOperationsInput | boolean
    panic_strike?: IntFieldUpdateOperationsInput | number
    spoofing_attempts?: IntFieldUpdateOperationsInput | number
    place_of_birth?: NullableStringFieldUpdateOperationsInput | string | null
    date_of_birth?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type panic_button_logsCreateManyOfficersInput = {
    id?: string
    user_id: string
    incident_logs_id: string
    timestamp?: Date | string
  }

  export type messagesCreateManySender_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesCreateManyRecipient_officerInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    inbox_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type panic_button_logsUpdateWithoutOfficersInput = {
    id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    incidents?: incident_logsUpdateOneRequiredWithoutPanic_button_logsNestedInput
    users?: usersUpdateOneRequiredWithoutPanic_button_logsNestedInput
  }

  export type panic_button_logsUncheckedUpdateWithoutOfficersInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type panic_button_logsUncheckedUpdateManyWithoutOfficersInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    incident_logs_id?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type messagesUpdateWithoutSender_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_user?: usersUpdateOneWithoutSentMessagesNestedInput
    recipient_user?: usersUpdateOneWithoutReceivedMessagesNestedInput
    recipient_officer?: officersUpdateOneWithoutReceivedMessagesNestedInput
    inbox?: inboxUpdateOneWithoutMessagesNestedInput
  }

  export type messagesUncheckedUpdateWithoutSender_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyWithoutSender_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUpdateWithoutRecipient_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_user?: usersUpdateOneWithoutSentMessagesNestedInput
    sender_officer?: officersUpdateOneWithoutSentMessagesNestedInput
    recipient_user?: usersUpdateOneWithoutReceivedMessagesNestedInput
    inbox?: inboxUpdateOneWithoutMessagesNestedInput
  }

  export type messagesUncheckedUpdateWithoutRecipient_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyWithoutRecipient_officerInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    inbox_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesCreateManyInboxInput = {
    id?: string
    subject: string
    content: string
    message_type?: string | null
    message_type_label?: string | null
    sender_user_id?: string | null
    sender_officer_id?: string | null
    recipient_user_id?: string | null
    recipient_officer_id?: string | null
    status?: $Enums.status_messages
    created_at?: Date | string
    updated_at?: Date | string
    file_url?: string | null
    file_type?: string | null
    file_name?: string | null
    is_starred?: boolean
  }

  export type messagesUpdateWithoutInboxInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
    sender_user?: usersUpdateOneWithoutSentMessagesNestedInput
    sender_officer?: officersUpdateOneWithoutSentMessagesNestedInput
    recipient_user?: usersUpdateOneWithoutReceivedMessagesNestedInput
    recipient_officer?: officersUpdateOneWithoutReceivedMessagesNestedInput
  }

  export type messagesUncheckedUpdateWithoutInboxInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type messagesUncheckedUpdateManyWithoutInboxInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    message_type?: NullableStringFieldUpdateOperationsInput | string | null
    message_type_label?: NullableStringFieldUpdateOperationsInput | string | null
    sender_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    sender_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_user_id?: NullableStringFieldUpdateOperationsInput | string | null
    recipient_officer_id?: NullableStringFieldUpdateOperationsInput | string | null
    status?: Enumstatus_messagesFieldUpdateOperationsInput | $Enums.status_messages
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    file_url?: NullableStringFieldUpdateOperationsInput | string | null
    file_type?: NullableStringFieldUpdateOperationsInput | string | null
    file_name?: NullableStringFieldUpdateOperationsInput | string | null
    is_starred?: BoolFieldUpdateOperationsInput | boolean
  }

  export type datasetsCreateManyProjectsInput = {
    id?: string
    filename: string
    original_name: string
    file_size: number
    columns: JsonNullValueInput | InputJsonValue
    row_count: number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: Date | string
  }

  export type analysesCreateManyProjectsInput = {
    id?: string
    dataset_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type datasetsUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: analysesUpdateManyWithoutDatasetsNestedInput
  }

  export type datasetsUncheckedUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    analyses?: analysesUncheckedUpdateManyWithoutDatasetsNestedInput
  }

  export type datasetsUncheckedUpdateManyWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    original_name?: StringFieldUpdateOperationsInput | string
    file_size?: IntFieldUpdateOperationsInput | number
    columns?: JsonNullValueInput | InputJsonValue
    row_count?: IntFieldUpdateOperationsInput | number
    metadata?: NullableJsonNullValueInput | InputJsonValue
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysesUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    datasets?: datasetsUpdateOneRequiredWithoutAnalysesNestedInput
    clusters?: clustersUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    dataset_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    clusters?: clustersUncheckedUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateManyWithoutProjectsInput = {
    id?: StringFieldUpdateOperationsInput | string
    dataset_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type analysesCreateManyDatasetsInput = {
    id?: string
    project_id: string
    name: string
    config: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type analysesUpdateWithoutDatasetsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    projects?: projectsUpdateOneRequiredWithoutAnalysesNestedInput
    clusters?: clustersUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateWithoutDatasetsInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    clusters?: clustersUncheckedUpdateManyWithoutAnalysesNestedInput
  }

  export type analysesUncheckedUpdateManyWithoutDatasetsInput = {
    id?: StringFieldUpdateOperationsInput | string
    project_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    config?: JsonNullValueInput | InputJsonValue
    results?: NullableJsonNullValueInput | InputJsonValue
    status?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type clustersCreateManyAnalysesInput = {
    id?: string
    cluster_id: number
    center_data: JsonNullValueInput | InputJsonValue
    point_count: number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUncheckedUpdateWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }

  export type clustersUncheckedUpdateManyWithoutAnalysesInput = {
    id?: StringFieldUpdateOperationsInput | string
    cluster_id?: IntFieldUpdateOperationsInput | number
    center_data?: JsonNullValueInput | InputJsonValue
    point_count?: IntFieldUpdateOperationsInput | number
    characteristics?: NullableJsonNullValueInput | InputJsonValue
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}