/**
 * Client
**/

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

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


/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model Burrow
 * 
 */
export type Burrow = $Result.DefaultSelection<Prisma.$BurrowPayload>
/**
 * Model Donation
 * 
 */
export type Donation = $Result.DefaultSelection<Prisma.$DonationPayload>
/**
 * Model WildlifeSighting
 * 
 */
export type WildlifeSighting = $Result.DefaultSelection<Prisma.$WildlifeSightingPayload>
/**
 * Model Event
 * 
 */
export type Event = $Result.DefaultSelection<Prisma.$EventPayload>
/**
 * Model EventRSVP
 * 
 */
export type EventRSVP = $Result.DefaultSelection<Prisma.$EventRSVPPayload>
/**
 * Model LivestreamSource
 * 
 */
export type LivestreamSource = $Result.DefaultSelection<Prisma.$LivestreamSourcePayload>
/**
 * Model VolunteerHour
 * 
 */
export type VolunteerHour = $Result.DefaultSelection<Prisma.$VolunteerHourPayload>
/**
 * Model EquipmentItem
 * 
 */
export type EquipmentItem = $Result.DefaultSelection<Prisma.$EquipmentItemPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const UserRole: {
  admin: 'admin',
  volunteer: 'volunteer',
  donor: 'donor',
  public: 'public'
};

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


export const BurrowStatus: {
  active: 'active',
  inactive: 'inactive',
  destroyed: 'destroyed'
};

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


export const DonationCampaign: {
  land_preservation: 'land_preservation',
  volunteer_equipment: 'volunteer_equipment',
  general: 'general'
};

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


export const EventType: {
  cleanup: 'cleanup',
  educational: 'educational',
  fundraiser: 'fundraiser'
};

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


export const StreamStatus: {
  live: 'live',
  offline: 'offline'
};

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


export const EquipmentStatus: {
  available: 'available',
  checked_out: 'checked_out'
};

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

}

export type UserRole = $Enums.UserRole

export const UserRole: typeof $Enums.UserRole

export type BurrowStatus = $Enums.BurrowStatus

export const BurrowStatus: typeof $Enums.BurrowStatus

export type DonationCampaign = $Enums.DonationCampaign

export const DonationCampaign: typeof $Enums.DonationCampaign

export type EventType = $Enums.EventType

export const EventType: typeof $Enums.EventType

export type StreamStatus = $Enums.StreamStatus

export const StreamStatus: typeof $Enums.StreamStatus

export type EquipmentStatus = $Enums.EquipmentStatus

export const EquipmentStatus: typeof $Enums.EquipmentStatus

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

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

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

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

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

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

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

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

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

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


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

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


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

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

  /**
   * `prisma.burrow`: Exposes CRUD operations for the **Burrow** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Burrows
    * const burrows = await prisma.burrow.findMany()
    * ```
    */
  get burrow(): Prisma.BurrowDelegate<ExtArgs>;

  /**
   * `prisma.donation`: Exposes CRUD operations for the **Donation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Donations
    * const donations = await prisma.donation.findMany()
    * ```
    */
  get donation(): Prisma.DonationDelegate<ExtArgs>;

  /**
   * `prisma.wildlifeSighting`: Exposes CRUD operations for the **WildlifeSighting** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more WildlifeSightings
    * const wildlifeSightings = await prisma.wildlifeSighting.findMany()
    * ```
    */
  get wildlifeSighting(): Prisma.WildlifeSightingDelegate<ExtArgs>;

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

  /**
   * `prisma.eventRSVP`: Exposes CRUD operations for the **EventRSVP** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more EventRSVPS
    * const eventRSVPS = await prisma.eventRSVP.findMany()
    * ```
    */
  get eventRSVP(): Prisma.EventRSVPDelegate<ExtArgs>;

  /**
   * `prisma.livestreamSource`: Exposes CRUD operations for the **LivestreamSource** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more LivestreamSources
    * const livestreamSources = await prisma.livestreamSource.findMany()
    * ```
    */
  get livestreamSource(): Prisma.LivestreamSourceDelegate<ExtArgs>;

  /**
   * `prisma.volunteerHour`: Exposes CRUD operations for the **VolunteerHour** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more VolunteerHours
    * const volunteerHours = await prisma.volunteerHour.findMany()
    * ```
    */
  get volunteerHour(): Prisma.VolunteerHourDelegate<ExtArgs>;

  /**
   * `prisma.equipmentItem`: Exposes CRUD operations for the **EquipmentItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more EquipmentItems
    * const equipmentItems = await prisma.equipmentItem.findMany()
    * ```
    */
  get equipmentItem(): Prisma.EquipmentItemDelegate<ExtArgs>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

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

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

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

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

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

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


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    User: 'User',
    Burrow: 'Burrow',
    Donation: 'Donation',
    WildlifeSighting: 'WildlifeSighting',
    Event: 'Event',
    EventRSVP: 'EventRSVP',
    LivestreamSource: 'LivestreamSource',
    VolunteerHour: 'VolunteerHour',
    EquipmentItem: 'EquipmentItem'
  };

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


  export type Datasources = {
    db?: Datasource
  }

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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "user" | "burrow" | "donation" | "wildlifeSighting" | "event" | "eventRSVP" | "livestreamSource" | "volunteerHour" | "equipmentItem"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      Burrow: {
        payload: Prisma.$BurrowPayload<ExtArgs>
        fields: Prisma.BurrowFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BurrowFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BurrowFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          findFirst: {
            args: Prisma.BurrowFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BurrowFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          findMany: {
            args: Prisma.BurrowFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>[]
          }
          create: {
            args: Prisma.BurrowCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          createMany: {
            args: Prisma.BurrowCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BurrowCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>[]
          }
          delete: {
            args: Prisma.BurrowDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          update: {
            args: Prisma.BurrowUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          deleteMany: {
            args: Prisma.BurrowDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BurrowUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BurrowUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BurrowPayload>
          }
          aggregate: {
            args: Prisma.BurrowAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBurrow>
          }
          groupBy: {
            args: Prisma.BurrowGroupByArgs<ExtArgs>
            result: $Utils.Optional<BurrowGroupByOutputType>[]
          }
          count: {
            args: Prisma.BurrowCountArgs<ExtArgs>
            result: $Utils.Optional<BurrowCountAggregateOutputType> | number
          }
        }
      }
      Donation: {
        payload: Prisma.$DonationPayload<ExtArgs>
        fields: Prisma.DonationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.DonationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.DonationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          findFirst: {
            args: Prisma.DonationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.DonationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          findMany: {
            args: Prisma.DonationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>[]
          }
          create: {
            args: Prisma.DonationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          createMany: {
            args: Prisma.DonationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.DonationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>[]
          }
          delete: {
            args: Prisma.DonationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          update: {
            args: Prisma.DonationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          deleteMany: {
            args: Prisma.DonationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.DonationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.DonationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DonationPayload>
          }
          aggregate: {
            args: Prisma.DonationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDonation>
          }
          groupBy: {
            args: Prisma.DonationGroupByArgs<ExtArgs>
            result: $Utils.Optional<DonationGroupByOutputType>[]
          }
          count: {
            args: Prisma.DonationCountArgs<ExtArgs>
            result: $Utils.Optional<DonationCountAggregateOutputType> | number
          }
        }
      }
      WildlifeSighting: {
        payload: Prisma.$WildlifeSightingPayload<ExtArgs>
        fields: Prisma.WildlifeSightingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WildlifeSightingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WildlifeSightingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          findFirst: {
            args: Prisma.WildlifeSightingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WildlifeSightingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          findMany: {
            args: Prisma.WildlifeSightingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>[]
          }
          create: {
            args: Prisma.WildlifeSightingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          createMany: {
            args: Prisma.WildlifeSightingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WildlifeSightingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>[]
          }
          delete: {
            args: Prisma.WildlifeSightingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          update: {
            args: Prisma.WildlifeSightingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          deleteMany: {
            args: Prisma.WildlifeSightingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WildlifeSightingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WildlifeSightingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WildlifeSightingPayload>
          }
          aggregate: {
            args: Prisma.WildlifeSightingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWildlifeSighting>
          }
          groupBy: {
            args: Prisma.WildlifeSightingGroupByArgs<ExtArgs>
            result: $Utils.Optional<WildlifeSightingGroupByOutputType>[]
          }
          count: {
            args: Prisma.WildlifeSightingCountArgs<ExtArgs>
            result: $Utils.Optional<WildlifeSightingCountAggregateOutputType> | number
          }
        }
      }
      Event: {
        payload: Prisma.$EventPayload<ExtArgs>
        fields: Prisma.EventFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EventFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EventFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          findFirst: {
            args: Prisma.EventFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EventFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          findMany: {
            args: Prisma.EventFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>[]
          }
          create: {
            args: Prisma.EventCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          createMany: {
            args: Prisma.EventCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.EventCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>[]
          }
          delete: {
            args: Prisma.EventDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          update: {
            args: Prisma.EventUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          deleteMany: {
            args: Prisma.EventDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EventUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EventUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventPayload>
          }
          aggregate: {
            args: Prisma.EventAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEvent>
          }
          groupBy: {
            args: Prisma.EventGroupByArgs<ExtArgs>
            result: $Utils.Optional<EventGroupByOutputType>[]
          }
          count: {
            args: Prisma.EventCountArgs<ExtArgs>
            result: $Utils.Optional<EventCountAggregateOutputType> | number
          }
        }
      }
      EventRSVP: {
        payload: Prisma.$EventRSVPPayload<ExtArgs>
        fields: Prisma.EventRSVPFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EventRSVPFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EventRSVPFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          findFirst: {
            args: Prisma.EventRSVPFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EventRSVPFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          findMany: {
            args: Prisma.EventRSVPFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>[]
          }
          create: {
            args: Prisma.EventRSVPCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          createMany: {
            args: Prisma.EventRSVPCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.EventRSVPCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>[]
          }
          delete: {
            args: Prisma.EventRSVPDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          update: {
            args: Prisma.EventRSVPUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          deleteMany: {
            args: Prisma.EventRSVPDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EventRSVPUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EventRSVPUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventRSVPPayload>
          }
          aggregate: {
            args: Prisma.EventRSVPAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEventRSVP>
          }
          groupBy: {
            args: Prisma.EventRSVPGroupByArgs<ExtArgs>
            result: $Utils.Optional<EventRSVPGroupByOutputType>[]
          }
          count: {
            args: Prisma.EventRSVPCountArgs<ExtArgs>
            result: $Utils.Optional<EventRSVPCountAggregateOutputType> | number
          }
        }
      }
      LivestreamSource: {
        payload: Prisma.$LivestreamSourcePayload<ExtArgs>
        fields: Prisma.LivestreamSourceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LivestreamSourceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LivestreamSourceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          findFirst: {
            args: Prisma.LivestreamSourceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LivestreamSourceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          findMany: {
            args: Prisma.LivestreamSourceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>[]
          }
          create: {
            args: Prisma.LivestreamSourceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          createMany: {
            args: Prisma.LivestreamSourceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LivestreamSourceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>[]
          }
          delete: {
            args: Prisma.LivestreamSourceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          update: {
            args: Prisma.LivestreamSourceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          deleteMany: {
            args: Prisma.LivestreamSourceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LivestreamSourceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LivestreamSourceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LivestreamSourcePayload>
          }
          aggregate: {
            args: Prisma.LivestreamSourceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLivestreamSource>
          }
          groupBy: {
            args: Prisma.LivestreamSourceGroupByArgs<ExtArgs>
            result: $Utils.Optional<LivestreamSourceGroupByOutputType>[]
          }
          count: {
            args: Prisma.LivestreamSourceCountArgs<ExtArgs>
            result: $Utils.Optional<LivestreamSourceCountAggregateOutputType> | number
          }
        }
      }
      VolunteerHour: {
        payload: Prisma.$VolunteerHourPayload<ExtArgs>
        fields: Prisma.VolunteerHourFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VolunteerHourFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VolunteerHourFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          findFirst: {
            args: Prisma.VolunteerHourFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VolunteerHourFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          findMany: {
            args: Prisma.VolunteerHourFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>[]
          }
          create: {
            args: Prisma.VolunteerHourCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          createMany: {
            args: Prisma.VolunteerHourCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.VolunteerHourCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>[]
          }
          delete: {
            args: Prisma.VolunteerHourDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          update: {
            args: Prisma.VolunteerHourUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          deleteMany: {
            args: Prisma.VolunteerHourDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VolunteerHourUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VolunteerHourUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VolunteerHourPayload>
          }
          aggregate: {
            args: Prisma.VolunteerHourAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVolunteerHour>
          }
          groupBy: {
            args: Prisma.VolunteerHourGroupByArgs<ExtArgs>
            result: $Utils.Optional<VolunteerHourGroupByOutputType>[]
          }
          count: {
            args: Prisma.VolunteerHourCountArgs<ExtArgs>
            result: $Utils.Optional<VolunteerHourCountAggregateOutputType> | number
          }
        }
      }
      EquipmentItem: {
        payload: Prisma.$EquipmentItemPayload<ExtArgs>
        fields: Prisma.EquipmentItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EquipmentItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EquipmentItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          findFirst: {
            args: Prisma.EquipmentItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EquipmentItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          findMany: {
            args: Prisma.EquipmentItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>[]
          }
          create: {
            args: Prisma.EquipmentItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          createMany: {
            args: Prisma.EquipmentItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.EquipmentItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>[]
          }
          delete: {
            args: Prisma.EquipmentItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          update: {
            args: Prisma.EquipmentItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          deleteMany: {
            args: Prisma.EquipmentItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EquipmentItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EquipmentItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentItemPayload>
          }
          aggregate: {
            args: Prisma.EquipmentItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEquipmentItem>
          }
          groupBy: {
            args: Prisma.EquipmentItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<EquipmentItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.EquipmentItemCountArgs<ExtArgs>
            result: $Utils.Optional<EquipmentItemCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { emit: 'stdout', level: 'query' },
     *   { emit: 'stdout', level: 'info' },
     *   { emit: 'stdout', level: 'warn' }
     *   { emit: 'stdout', level: 'error' }
     * ]
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
  }


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

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

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

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


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

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

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

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

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

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    burrows: number
    donations: number
    sightings: number
    event_rsvps: number
    volunteer_hours: number
    equipment_items: number
    verified_hours: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    burrows?: boolean | UserCountOutputTypeCountBurrowsArgs
    donations?: boolean | UserCountOutputTypeCountDonationsArgs
    sightings?: boolean | UserCountOutputTypeCountSightingsArgs
    event_rsvps?: boolean | UserCountOutputTypeCountEvent_rsvpsArgs
    volunteer_hours?: boolean | UserCountOutputTypeCountVolunteer_hoursArgs
    equipment_items?: boolean | UserCountOutputTypeCountEquipment_itemsArgs
    verified_hours?: boolean | UserCountOutputTypeCountVerified_hoursArgs
  }

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

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

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

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

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

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

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

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


  /**
   * Count Type EventCountOutputType
   */

  export type EventCountOutputType = {
    rsvps: number
  }

  export type EventCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rsvps?: boolean | EventCountOutputTypeCountRsvpsArgs
  }

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

  /**
   * EventCountOutputType without action
   */
  export type EventCountOutputTypeCountRsvpsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventRSVPWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    role: $Enums.UserRole | null
    password_hash: string | null
    created_at: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    role: $Enums.UserRole | null
    password_hash: string | null
    created_at: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    email: number
    name: number
    role: number
    password_hash: number
    created_at: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    email?: true
    name?: true
    role?: true
    password_hash?: true
    created_at?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    email?: true
    name?: true
    role?: true
    password_hash?: true
    created_at?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    email?: true
    name?: true
    role?: true
    password_hash?: true
    created_at?: true
    _all?: true
  }

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

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




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

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

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    name?: boolean
    role?: boolean
    password_hash?: boolean
    created_at?: boolean
    burrows?: boolean | User$burrowsArgs<ExtArgs>
    donations?: boolean | User$donationsArgs<ExtArgs>
    sightings?: boolean | User$sightingsArgs<ExtArgs>
    event_rsvps?: boolean | User$event_rsvpsArgs<ExtArgs>
    volunteer_hours?: boolean | User$volunteer_hoursArgs<ExtArgs>
    equipment_items?: boolean | User$equipment_itemsArgs<ExtArgs>
    verified_hours?: boolean | User$verified_hoursArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

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

  export type UserSelectScalar = {
    id?: boolean
    email?: boolean
    name?: boolean
    role?: boolean
    password_hash?: boolean
    created_at?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    burrows?: boolean | User$burrowsArgs<ExtArgs>
    donations?: boolean | User$donationsArgs<ExtArgs>
    sightings?: boolean | User$sightingsArgs<ExtArgs>
    event_rsvps?: boolean | User$event_rsvpsArgs<ExtArgs>
    volunteer_hours?: boolean | User$volunteer_hoursArgs<ExtArgs>
    equipment_items?: boolean | User$equipment_itemsArgs<ExtArgs>
    verified_hours?: boolean | User$verified_hoursArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      burrows: Prisma.$BurrowPayload<ExtArgs>[]
      donations: Prisma.$DonationPayload<ExtArgs>[]
      sightings: Prisma.$WildlifeSightingPayload<ExtArgs>[]
      event_rsvps: Prisma.$EventRSVPPayload<ExtArgs>[]
      volunteer_hours: Prisma.$VolunteerHourPayload<ExtArgs>[]
      equipment_items: Prisma.$EquipmentItemPayload<ExtArgs>[]
      verified_hours: Prisma.$VolunteerHourPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string
      name: string
      role: $Enums.UserRole
      password_hash: string
      created_at: Date
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * User.burrows
   */
  export type User$burrowsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    where?: BurrowWhereInput
    orderBy?: BurrowOrderByWithRelationInput | BurrowOrderByWithRelationInput[]
    cursor?: BurrowWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BurrowScalarFieldEnum | BurrowScalarFieldEnum[]
  }

  /**
   * User.donations
   */
  export type User$donationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    where?: DonationWhereInput
    orderBy?: DonationOrderByWithRelationInput | DonationOrderByWithRelationInput[]
    cursor?: DonationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DonationScalarFieldEnum | DonationScalarFieldEnum[]
  }

  /**
   * User.sightings
   */
  export type User$sightingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    where?: WildlifeSightingWhereInput
    orderBy?: WildlifeSightingOrderByWithRelationInput | WildlifeSightingOrderByWithRelationInput[]
    cursor?: WildlifeSightingWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WildlifeSightingScalarFieldEnum | WildlifeSightingScalarFieldEnum[]
  }

  /**
   * User.event_rsvps
   */
  export type User$event_rsvpsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    where?: EventRSVPWhereInput
    orderBy?: EventRSVPOrderByWithRelationInput | EventRSVPOrderByWithRelationInput[]
    cursor?: EventRSVPWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventRSVPScalarFieldEnum | EventRSVPScalarFieldEnum[]
  }

  /**
   * User.volunteer_hours
   */
  export type User$volunteer_hoursArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    where?: VolunteerHourWhereInput
    orderBy?: VolunteerHourOrderByWithRelationInput | VolunteerHourOrderByWithRelationInput[]
    cursor?: VolunteerHourWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VolunteerHourScalarFieldEnum | VolunteerHourScalarFieldEnum[]
  }

  /**
   * User.equipment_items
   */
  export type User$equipment_itemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    where?: EquipmentItemWhereInput
    orderBy?: EquipmentItemOrderByWithRelationInput | EquipmentItemOrderByWithRelationInput[]
    cursor?: EquipmentItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EquipmentItemScalarFieldEnum | EquipmentItemScalarFieldEnum[]
  }

  /**
   * User.verified_hours
   */
  export type User$verified_hoursArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    where?: VolunteerHourWhereInput
    orderBy?: VolunteerHourOrderByWithRelationInput | VolunteerHourOrderByWithRelationInput[]
    cursor?: VolunteerHourWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VolunteerHourScalarFieldEnum | VolunteerHourScalarFieldEnum[]
  }

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


  /**
   * Model Burrow
   */

  export type AggregateBurrow = {
    _count: BurrowCountAggregateOutputType | null
    _avg: BurrowAvgAggregateOutputType | null
    _sum: BurrowSumAggregateOutputType | null
    _min: BurrowMinAggregateOutputType | null
    _max: BurrowMaxAggregateOutputType | null
  }

  export type BurrowAvgAggregateOutputType = {
    gps_lat: number | null
    gps_lng: number | null
  }

  export type BurrowSumAggregateOutputType = {
    gps_lat: number | null
    gps_lng: number | null
  }

  export type BurrowMinAggregateOutputType = {
    id: string | null
    gps_lat: number | null
    gps_lng: number | null
    status: $Enums.BurrowStatus | null
    location_description: string | null
    assigned_volunteer_id: string | null
    created_at: Date | null
  }

  export type BurrowMaxAggregateOutputType = {
    id: string | null
    gps_lat: number | null
    gps_lng: number | null
    status: $Enums.BurrowStatus | null
    location_description: string | null
    assigned_volunteer_id: string | null
    created_at: Date | null
  }

  export type BurrowCountAggregateOutputType = {
    id: number
    gps_lat: number
    gps_lng: number
    status: number
    location_description: number
    photos: number
    assigned_volunteer_id: number
    created_at: number
    _all: number
  }


  export type BurrowAvgAggregateInputType = {
    gps_lat?: true
    gps_lng?: true
  }

  export type BurrowSumAggregateInputType = {
    gps_lat?: true
    gps_lng?: true
  }

  export type BurrowMinAggregateInputType = {
    id?: true
    gps_lat?: true
    gps_lng?: true
    status?: true
    location_description?: true
    assigned_volunteer_id?: true
    created_at?: true
  }

  export type BurrowMaxAggregateInputType = {
    id?: true
    gps_lat?: true
    gps_lng?: true
    status?: true
    location_description?: true
    assigned_volunteer_id?: true
    created_at?: true
  }

  export type BurrowCountAggregateInputType = {
    id?: true
    gps_lat?: true
    gps_lng?: true
    status?: true
    location_description?: true
    photos?: true
    assigned_volunteer_id?: true
    created_at?: true
    _all?: true
  }

  export type BurrowAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Burrow to aggregate.
     */
    where?: BurrowWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Burrows to fetch.
     */
    orderBy?: BurrowOrderByWithRelationInput | BurrowOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BurrowWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Burrows from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Burrows.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Burrows
    **/
    _count?: true | BurrowCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: BurrowAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: BurrowSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BurrowMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BurrowMaxAggregateInputType
  }

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




  export type BurrowGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BurrowWhereInput
    orderBy?: BurrowOrderByWithAggregationInput | BurrowOrderByWithAggregationInput[]
    by: BurrowScalarFieldEnum[] | BurrowScalarFieldEnum
    having?: BurrowScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BurrowCountAggregateInputType | true
    _avg?: BurrowAvgAggregateInputType
    _sum?: BurrowSumAggregateInputType
    _min?: BurrowMinAggregateInputType
    _max?: BurrowMaxAggregateInputType
  }

  export type BurrowGroupByOutputType = {
    id: string
    gps_lat: number
    gps_lng: number
    status: $Enums.BurrowStatus
    location_description: string | null
    photos: string[]
    assigned_volunteer_id: string | null
    created_at: Date
    _count: BurrowCountAggregateOutputType | null
    _avg: BurrowAvgAggregateOutputType | null
    _sum: BurrowSumAggregateOutputType | null
    _min: BurrowMinAggregateOutputType | null
    _max: BurrowMaxAggregateOutputType | null
  }

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


  export type BurrowSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    status?: boolean
    location_description?: boolean
    photos?: boolean
    assigned_volunteer_id?: boolean
    created_at?: boolean
    assigned_volunteer?: boolean | Burrow$assigned_volunteerArgs<ExtArgs>
  }, ExtArgs["result"]["burrow"]>

  export type BurrowSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    status?: boolean
    location_description?: boolean
    photos?: boolean
    assigned_volunteer_id?: boolean
    created_at?: boolean
    assigned_volunteer?: boolean | Burrow$assigned_volunteerArgs<ExtArgs>
  }, ExtArgs["result"]["burrow"]>

  export type BurrowSelectScalar = {
    id?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    status?: boolean
    location_description?: boolean
    photos?: boolean
    assigned_volunteer_id?: boolean
    created_at?: boolean
  }

  export type BurrowInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    assigned_volunteer?: boolean | Burrow$assigned_volunteerArgs<ExtArgs>
  }
  export type BurrowIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    assigned_volunteer?: boolean | Burrow$assigned_volunteerArgs<ExtArgs>
  }

  export type $BurrowPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Burrow"
    objects: {
      assigned_volunteer: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      gps_lat: number
      gps_lng: number
      status: $Enums.BurrowStatus
      location_description: string | null
      photos: string[]
      assigned_volunteer_id: string | null
      created_at: Date
    }, ExtArgs["result"]["burrow"]>
    composites: {}
  }

  type BurrowGetPayload<S extends boolean | null | undefined | BurrowDefaultArgs> = $Result.GetResult<Prisma.$BurrowPayload, S>

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

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

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

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

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

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

    /**
     * Create a Burrow.
     * @param {BurrowCreateArgs} args - Arguments to create a Burrow.
     * @example
     * // Create one Burrow
     * const Burrow = await prisma.burrow.create({
     *   data: {
     *     // ... data to create a Burrow
     *   }
     * })
     * 
     */
    create<T extends BurrowCreateArgs>(args: SelectSubset<T, BurrowCreateArgs<ExtArgs>>): Prisma__BurrowClient<$Result.GetResult<Prisma.$BurrowPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Burrow.
     * @param {BurrowDeleteArgs} args - Arguments to delete one Burrow.
     * @example
     * // Delete one Burrow
     * const Burrow = await prisma.burrow.delete({
     *   where: {
     *     // ... filter to delete one Burrow
     *   }
     * })
     * 
     */
    delete<T extends BurrowDeleteArgs>(args: SelectSubset<T, BurrowDeleteArgs<ExtArgs>>): Prisma__BurrowClient<$Result.GetResult<Prisma.$BurrowPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the Burrow model
   */ 
  interface BurrowFieldRefs {
    readonly id: FieldRef<"Burrow", 'String'>
    readonly gps_lat: FieldRef<"Burrow", 'Float'>
    readonly gps_lng: FieldRef<"Burrow", 'Float'>
    readonly status: FieldRef<"Burrow", 'BurrowStatus'>
    readonly location_description: FieldRef<"Burrow", 'String'>
    readonly photos: FieldRef<"Burrow", 'String[]'>
    readonly assigned_volunteer_id: FieldRef<"Burrow", 'String'>
    readonly created_at: FieldRef<"Burrow", 'DateTime'>
  }
    

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

  /**
   * Burrow findUniqueOrThrow
   */
  export type BurrowFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    /**
     * Filter, which Burrow to fetch.
     */
    where: BurrowWhereUniqueInput
  }

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

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

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

  /**
   * Burrow create
   */
  export type BurrowCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    /**
     * The data needed to create a Burrow.
     */
    data: XOR<BurrowCreateInput, BurrowUncheckedCreateInput>
  }

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

  /**
   * Burrow createManyAndReturn
   */
  export type BurrowCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Burrows.
     */
    data: BurrowCreateManyInput | BurrowCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Burrow update
   */
  export type BurrowUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    /**
     * The data needed to update a Burrow.
     */
    data: XOR<BurrowUpdateInput, BurrowUncheckedUpdateInput>
    /**
     * Choose, which Burrow to update.
     */
    where: BurrowWhereUniqueInput
  }

  /**
   * Burrow updateMany
   */
  export type BurrowUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Burrows.
     */
    data: XOR<BurrowUpdateManyMutationInput, BurrowUncheckedUpdateManyInput>
    /**
     * Filter which Burrows to update
     */
    where?: BurrowWhereInput
  }

  /**
   * Burrow upsert
   */
  export type BurrowUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    /**
     * The filter to search for the Burrow to update in case it exists.
     */
    where: BurrowWhereUniqueInput
    /**
     * In case the Burrow found by the `where` argument doesn't exist, create a new Burrow with this data.
     */
    create: XOR<BurrowCreateInput, BurrowUncheckedCreateInput>
    /**
     * In case the Burrow was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BurrowUpdateInput, BurrowUncheckedUpdateInput>
  }

  /**
   * Burrow delete
   */
  export type BurrowDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Burrow
     */
    select?: BurrowSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BurrowInclude<ExtArgs> | null
    /**
     * Filter which Burrow to delete.
     */
    where: BurrowWhereUniqueInput
  }

  /**
   * Burrow deleteMany
   */
  export type BurrowDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Burrows to delete
     */
    where?: BurrowWhereInput
  }

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

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


  /**
   * Model Donation
   */

  export type AggregateDonation = {
    _count: DonationCountAggregateOutputType | null
    _avg: DonationAvgAggregateOutputType | null
    _sum: DonationSumAggregateOutputType | null
    _min: DonationMinAggregateOutputType | null
    _max: DonationMaxAggregateOutputType | null
  }

  export type DonationAvgAggregateOutputType = {
    amount: number | null
  }

  export type DonationSumAggregateOutputType = {
    amount: number | null
  }

  export type DonationMinAggregateOutputType = {
    id: string | null
    donor_id: string | null
    amount: number | null
    campaign: $Enums.DonationCampaign | null
    stripe_payment_id: string | null
    created_at: Date | null
  }

  export type DonationMaxAggregateOutputType = {
    id: string | null
    donor_id: string | null
    amount: number | null
    campaign: $Enums.DonationCampaign | null
    stripe_payment_id: string | null
    created_at: Date | null
  }

  export type DonationCountAggregateOutputType = {
    id: number
    donor_id: number
    amount: number
    campaign: number
    stripe_payment_id: number
    created_at: number
    _all: number
  }


  export type DonationAvgAggregateInputType = {
    amount?: true
  }

  export type DonationSumAggregateInputType = {
    amount?: true
  }

  export type DonationMinAggregateInputType = {
    id?: true
    donor_id?: true
    amount?: true
    campaign?: true
    stripe_payment_id?: true
    created_at?: true
  }

  export type DonationMaxAggregateInputType = {
    id?: true
    donor_id?: true
    amount?: true
    campaign?: true
    stripe_payment_id?: true
    created_at?: true
  }

  export type DonationCountAggregateInputType = {
    id?: true
    donor_id?: true
    amount?: true
    campaign?: true
    stripe_payment_id?: true
    created_at?: true
    _all?: true
  }

  export type DonationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Donation to aggregate.
     */
    where?: DonationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Donations to fetch.
     */
    orderBy?: DonationOrderByWithRelationInput | DonationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: DonationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Donations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Donations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Donations
    **/
    _count?: true | DonationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DonationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DonationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DonationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DonationMaxAggregateInputType
  }

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




  export type DonationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: DonationWhereInput
    orderBy?: DonationOrderByWithAggregationInput | DonationOrderByWithAggregationInput[]
    by: DonationScalarFieldEnum[] | DonationScalarFieldEnum
    having?: DonationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DonationCountAggregateInputType | true
    _avg?: DonationAvgAggregateInputType
    _sum?: DonationSumAggregateInputType
    _min?: DonationMinAggregateInputType
    _max?: DonationMaxAggregateInputType
  }

  export type DonationGroupByOutputType = {
    id: string
    donor_id: string | null
    amount: number
    campaign: $Enums.DonationCampaign
    stripe_payment_id: string | null
    created_at: Date
    _count: DonationCountAggregateOutputType | null
    _avg: DonationAvgAggregateOutputType | null
    _sum: DonationSumAggregateOutputType | null
    _min: DonationMinAggregateOutputType | null
    _max: DonationMaxAggregateOutputType | null
  }

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


  export type DonationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    donor_id?: boolean
    amount?: boolean
    campaign?: boolean
    stripe_payment_id?: boolean
    created_at?: boolean
    donor?: boolean | Donation$donorArgs<ExtArgs>
  }, ExtArgs["result"]["donation"]>

  export type DonationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    donor_id?: boolean
    amount?: boolean
    campaign?: boolean
    stripe_payment_id?: boolean
    created_at?: boolean
    donor?: boolean | Donation$donorArgs<ExtArgs>
  }, ExtArgs["result"]["donation"]>

  export type DonationSelectScalar = {
    id?: boolean
    donor_id?: boolean
    amount?: boolean
    campaign?: boolean
    stripe_payment_id?: boolean
    created_at?: boolean
  }

  export type DonationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    donor?: boolean | Donation$donorArgs<ExtArgs>
  }
  export type DonationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    donor?: boolean | Donation$donorArgs<ExtArgs>
  }

  export type $DonationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Donation"
    objects: {
      donor: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      donor_id: string | null
      amount: number
      campaign: $Enums.DonationCampaign
      stripe_payment_id: string | null
      created_at: Date
    }, ExtArgs["result"]["donation"]>
    composites: {}
  }

  type DonationGetPayload<S extends boolean | null | undefined | DonationDefaultArgs> = $Result.GetResult<Prisma.$DonationPayload, S>

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

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

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

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

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

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

    /**
     * Create a Donation.
     * @param {DonationCreateArgs} args - Arguments to create a Donation.
     * @example
     * // Create one Donation
     * const Donation = await prisma.donation.create({
     *   data: {
     *     // ... data to create a Donation
     *   }
     * })
     * 
     */
    create<T extends DonationCreateArgs>(args: SelectSubset<T, DonationCreateArgs<ExtArgs>>): Prisma__DonationClient<$Result.GetResult<Prisma.$DonationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Donation.
     * @param {DonationDeleteArgs} args - Arguments to delete one Donation.
     * @example
     * // Delete one Donation
     * const Donation = await prisma.donation.delete({
     *   where: {
     *     // ... filter to delete one Donation
     *   }
     * })
     * 
     */
    delete<T extends DonationDeleteArgs>(args: SelectSubset<T, DonationDeleteArgs<ExtArgs>>): Prisma__DonationClient<$Result.GetResult<Prisma.$DonationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the Donation model
   */ 
  interface DonationFieldRefs {
    readonly id: FieldRef<"Donation", 'String'>
    readonly donor_id: FieldRef<"Donation", 'String'>
    readonly amount: FieldRef<"Donation", 'Float'>
    readonly campaign: FieldRef<"Donation", 'DonationCampaign'>
    readonly stripe_payment_id: FieldRef<"Donation", 'String'>
    readonly created_at: FieldRef<"Donation", 'DateTime'>
  }
    

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

  /**
   * Donation findUniqueOrThrow
   */
  export type DonationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    /**
     * Filter, which Donation to fetch.
     */
    where: DonationWhereUniqueInput
  }

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

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

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

  /**
   * Donation create
   */
  export type DonationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    /**
     * The data needed to create a Donation.
     */
    data: XOR<DonationCreateInput, DonationUncheckedCreateInput>
  }

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

  /**
   * Donation createManyAndReturn
   */
  export type DonationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Donations.
     */
    data: DonationCreateManyInput | DonationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Donation update
   */
  export type DonationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    /**
     * The data needed to update a Donation.
     */
    data: XOR<DonationUpdateInput, DonationUncheckedUpdateInput>
    /**
     * Choose, which Donation to update.
     */
    where: DonationWhereUniqueInput
  }

  /**
   * Donation updateMany
   */
  export type DonationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Donations.
     */
    data: XOR<DonationUpdateManyMutationInput, DonationUncheckedUpdateManyInput>
    /**
     * Filter which Donations to update
     */
    where?: DonationWhereInput
  }

  /**
   * Donation upsert
   */
  export type DonationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    /**
     * The filter to search for the Donation to update in case it exists.
     */
    where: DonationWhereUniqueInput
    /**
     * In case the Donation found by the `where` argument doesn't exist, create a new Donation with this data.
     */
    create: XOR<DonationCreateInput, DonationUncheckedCreateInput>
    /**
     * In case the Donation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<DonationUpdateInput, DonationUncheckedUpdateInput>
  }

  /**
   * Donation delete
   */
  export type DonationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Donation
     */
    select?: DonationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DonationInclude<ExtArgs> | null
    /**
     * Filter which Donation to delete.
     */
    where: DonationWhereUniqueInput
  }

  /**
   * Donation deleteMany
   */
  export type DonationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Donations to delete
     */
    where?: DonationWhereInput
  }

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

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


  /**
   * Model WildlifeSighting
   */

  export type AggregateWildlifeSighting = {
    _count: WildlifeSightingCountAggregateOutputType | null
    _avg: WildlifeSightingAvgAggregateOutputType | null
    _sum: WildlifeSightingSumAggregateOutputType | null
    _min: WildlifeSightingMinAggregateOutputType | null
    _max: WildlifeSightingMaxAggregateOutputType | null
  }

  export type WildlifeSightingAvgAggregateOutputType = {
    gps_lat: number | null
    gps_lng: number | null
  }

  export type WildlifeSightingSumAggregateOutputType = {
    gps_lat: number | null
    gps_lng: number | null
  }

  export type WildlifeSightingMinAggregateOutputType = {
    id: string | null
    reporter_id: string | null
    species: string | null
    gps_lat: number | null
    gps_lng: number | null
    photo_url: string | null
    description: string | null
    verified: boolean | null
    created_at: Date | null
  }

  export type WildlifeSightingMaxAggregateOutputType = {
    id: string | null
    reporter_id: string | null
    species: string | null
    gps_lat: number | null
    gps_lng: number | null
    photo_url: string | null
    description: string | null
    verified: boolean | null
    created_at: Date | null
  }

  export type WildlifeSightingCountAggregateOutputType = {
    id: number
    reporter_id: number
    species: number
    gps_lat: number
    gps_lng: number
    photo_url: number
    description: number
    verified: number
    created_at: number
    _all: number
  }


  export type WildlifeSightingAvgAggregateInputType = {
    gps_lat?: true
    gps_lng?: true
  }

  export type WildlifeSightingSumAggregateInputType = {
    gps_lat?: true
    gps_lng?: true
  }

  export type WildlifeSightingMinAggregateInputType = {
    id?: true
    reporter_id?: true
    species?: true
    gps_lat?: true
    gps_lng?: true
    photo_url?: true
    description?: true
    verified?: true
    created_at?: true
  }

  export type WildlifeSightingMaxAggregateInputType = {
    id?: true
    reporter_id?: true
    species?: true
    gps_lat?: true
    gps_lng?: true
    photo_url?: true
    description?: true
    verified?: true
    created_at?: true
  }

  export type WildlifeSightingCountAggregateInputType = {
    id?: true
    reporter_id?: true
    species?: true
    gps_lat?: true
    gps_lng?: true
    photo_url?: true
    description?: true
    verified?: true
    created_at?: true
    _all?: true
  }

  export type WildlifeSightingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WildlifeSighting to aggregate.
     */
    where?: WildlifeSightingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WildlifeSightings to fetch.
     */
    orderBy?: WildlifeSightingOrderByWithRelationInput | WildlifeSightingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: WildlifeSightingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WildlifeSightings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WildlifeSightings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned WildlifeSightings
    **/
    _count?: true | WildlifeSightingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: WildlifeSightingAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: WildlifeSightingSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: WildlifeSightingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: WildlifeSightingMaxAggregateInputType
  }

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




  export type WildlifeSightingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WildlifeSightingWhereInput
    orderBy?: WildlifeSightingOrderByWithAggregationInput | WildlifeSightingOrderByWithAggregationInput[]
    by: WildlifeSightingScalarFieldEnum[] | WildlifeSightingScalarFieldEnum
    having?: WildlifeSightingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WildlifeSightingCountAggregateInputType | true
    _avg?: WildlifeSightingAvgAggregateInputType
    _sum?: WildlifeSightingSumAggregateInputType
    _min?: WildlifeSightingMinAggregateInputType
    _max?: WildlifeSightingMaxAggregateInputType
  }

  export type WildlifeSightingGroupByOutputType = {
    id: string
    reporter_id: string | null
    species: string
    gps_lat: number
    gps_lng: number
    photo_url: string | null
    description: string | null
    verified: boolean
    created_at: Date
    _count: WildlifeSightingCountAggregateOutputType | null
    _avg: WildlifeSightingAvgAggregateOutputType | null
    _sum: WildlifeSightingSumAggregateOutputType | null
    _min: WildlifeSightingMinAggregateOutputType | null
    _max: WildlifeSightingMaxAggregateOutputType | null
  }

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


  export type WildlifeSightingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reporter_id?: boolean
    species?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    photo_url?: boolean
    description?: boolean
    verified?: boolean
    created_at?: boolean
    reporter?: boolean | WildlifeSighting$reporterArgs<ExtArgs>
  }, ExtArgs["result"]["wildlifeSighting"]>

  export type WildlifeSightingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    reporter_id?: boolean
    species?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    photo_url?: boolean
    description?: boolean
    verified?: boolean
    created_at?: boolean
    reporter?: boolean | WildlifeSighting$reporterArgs<ExtArgs>
  }, ExtArgs["result"]["wildlifeSighting"]>

  export type WildlifeSightingSelectScalar = {
    id?: boolean
    reporter_id?: boolean
    species?: boolean
    gps_lat?: boolean
    gps_lng?: boolean
    photo_url?: boolean
    description?: boolean
    verified?: boolean
    created_at?: boolean
  }

  export type WildlifeSightingInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    reporter?: boolean | WildlifeSighting$reporterArgs<ExtArgs>
  }
  export type WildlifeSightingIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    reporter?: boolean | WildlifeSighting$reporterArgs<ExtArgs>
  }

  export type $WildlifeSightingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WildlifeSighting"
    objects: {
      reporter: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      reporter_id: string | null
      species: string
      gps_lat: number
      gps_lng: number
      photo_url: string | null
      description: string | null
      verified: boolean
      created_at: Date
    }, ExtArgs["result"]["wildlifeSighting"]>
    composites: {}
  }

  type WildlifeSightingGetPayload<S extends boolean | null | undefined | WildlifeSightingDefaultArgs> = $Result.GetResult<Prisma.$WildlifeSightingPayload, S>

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

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

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

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

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

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

    /**
     * Create a WildlifeSighting.
     * @param {WildlifeSightingCreateArgs} args - Arguments to create a WildlifeSighting.
     * @example
     * // Create one WildlifeSighting
     * const WildlifeSighting = await prisma.wildlifeSighting.create({
     *   data: {
     *     // ... data to create a WildlifeSighting
     *   }
     * })
     * 
     */
    create<T extends WildlifeSightingCreateArgs>(args: SelectSubset<T, WildlifeSightingCreateArgs<ExtArgs>>): Prisma__WildlifeSightingClient<$Result.GetResult<Prisma.$WildlifeSightingPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a WildlifeSighting.
     * @param {WildlifeSightingDeleteArgs} args - Arguments to delete one WildlifeSighting.
     * @example
     * // Delete one WildlifeSighting
     * const WildlifeSighting = await prisma.wildlifeSighting.delete({
     *   where: {
     *     // ... filter to delete one WildlifeSighting
     *   }
     * })
     * 
     */
    delete<T extends WildlifeSightingDeleteArgs>(args: SelectSubset<T, WildlifeSightingDeleteArgs<ExtArgs>>): Prisma__WildlifeSightingClient<$Result.GetResult<Prisma.$WildlifeSightingPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the WildlifeSighting model
   */ 
  interface WildlifeSightingFieldRefs {
    readonly id: FieldRef<"WildlifeSighting", 'String'>
    readonly reporter_id: FieldRef<"WildlifeSighting", 'String'>
    readonly species: FieldRef<"WildlifeSighting", 'String'>
    readonly gps_lat: FieldRef<"WildlifeSighting", 'Float'>
    readonly gps_lng: FieldRef<"WildlifeSighting", 'Float'>
    readonly photo_url: FieldRef<"WildlifeSighting", 'String'>
    readonly description: FieldRef<"WildlifeSighting", 'String'>
    readonly verified: FieldRef<"WildlifeSighting", 'Boolean'>
    readonly created_at: FieldRef<"WildlifeSighting", 'DateTime'>
  }
    

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

  /**
   * WildlifeSighting findUniqueOrThrow
   */
  export type WildlifeSightingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    /**
     * Filter, which WildlifeSighting to fetch.
     */
    where: WildlifeSightingWhereUniqueInput
  }

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

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

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

  /**
   * WildlifeSighting create
   */
  export type WildlifeSightingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    /**
     * The data needed to create a WildlifeSighting.
     */
    data: XOR<WildlifeSightingCreateInput, WildlifeSightingUncheckedCreateInput>
  }

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

  /**
   * WildlifeSighting createManyAndReturn
   */
  export type WildlifeSightingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many WildlifeSightings.
     */
    data: WildlifeSightingCreateManyInput | WildlifeSightingCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * WildlifeSighting update
   */
  export type WildlifeSightingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    /**
     * The data needed to update a WildlifeSighting.
     */
    data: XOR<WildlifeSightingUpdateInput, WildlifeSightingUncheckedUpdateInput>
    /**
     * Choose, which WildlifeSighting to update.
     */
    where: WildlifeSightingWhereUniqueInput
  }

  /**
   * WildlifeSighting updateMany
   */
  export type WildlifeSightingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WildlifeSightings.
     */
    data: XOR<WildlifeSightingUpdateManyMutationInput, WildlifeSightingUncheckedUpdateManyInput>
    /**
     * Filter which WildlifeSightings to update
     */
    where?: WildlifeSightingWhereInput
  }

  /**
   * WildlifeSighting upsert
   */
  export type WildlifeSightingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    /**
     * The filter to search for the WildlifeSighting to update in case it exists.
     */
    where: WildlifeSightingWhereUniqueInput
    /**
     * In case the WildlifeSighting found by the `where` argument doesn't exist, create a new WildlifeSighting with this data.
     */
    create: XOR<WildlifeSightingCreateInput, WildlifeSightingUncheckedCreateInput>
    /**
     * In case the WildlifeSighting was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WildlifeSightingUpdateInput, WildlifeSightingUncheckedUpdateInput>
  }

  /**
   * WildlifeSighting delete
   */
  export type WildlifeSightingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WildlifeSighting
     */
    select?: WildlifeSightingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WildlifeSightingInclude<ExtArgs> | null
    /**
     * Filter which WildlifeSighting to delete.
     */
    where: WildlifeSightingWhereUniqueInput
  }

  /**
   * WildlifeSighting deleteMany
   */
  export type WildlifeSightingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WildlifeSightings to delete
     */
    where?: WildlifeSightingWhereInput
  }

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

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


  /**
   * Model Event
   */

  export type AggregateEvent = {
    _count: EventCountAggregateOutputType | null
    _avg: EventAvgAggregateOutputType | null
    _sum: EventSumAggregateOutputType | null
    _min: EventMinAggregateOutputType | null
    _max: EventMaxAggregateOutputType | null
  }

  export type EventAvgAggregateOutputType = {
    max_attendees: number | null
  }

  export type EventSumAggregateOutputType = {
    max_attendees: number | null
  }

  export type EventMinAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    date: Date | null
    location: string | null
    max_attendees: number | null
    type: $Enums.EventType | null
    created_at: Date | null
  }

  export type EventMaxAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    date: Date | null
    location: string | null
    max_attendees: number | null
    type: $Enums.EventType | null
    created_at: Date | null
  }

  export type EventCountAggregateOutputType = {
    id: number
    title: number
    description: number
    date: number
    location: number
    max_attendees: number
    type: number
    created_at: number
    _all: number
  }


  export type EventAvgAggregateInputType = {
    max_attendees?: true
  }

  export type EventSumAggregateInputType = {
    max_attendees?: true
  }

  export type EventMinAggregateInputType = {
    id?: true
    title?: true
    description?: true
    date?: true
    location?: true
    max_attendees?: true
    type?: true
    created_at?: true
  }

  export type EventMaxAggregateInputType = {
    id?: true
    title?: true
    description?: true
    date?: true
    location?: true
    max_attendees?: true
    type?: true
    created_at?: true
  }

  export type EventCountAggregateInputType = {
    id?: true
    title?: true
    description?: true
    date?: true
    location?: true
    max_attendees?: true
    type?: true
    created_at?: true
    _all?: true
  }

  export type EventAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Event to aggregate.
     */
    where?: EventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Events to fetch.
     */
    orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: EventWhereUniqueInput
    /**
     * {@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 | EventCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: EventAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: EventSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: EventMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: EventMaxAggregateInputType
  }

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




  export type EventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventWhereInput
    orderBy?: EventOrderByWithAggregationInput | EventOrderByWithAggregationInput[]
    by: EventScalarFieldEnum[] | EventScalarFieldEnum
    having?: EventScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventCountAggregateInputType | true
    _avg?: EventAvgAggregateInputType
    _sum?: EventSumAggregateInputType
    _min?: EventMinAggregateInputType
    _max?: EventMaxAggregateInputType
  }

  export type EventGroupByOutputType = {
    id: string
    title: string
    description: string | null
    date: Date
    location: string
    max_attendees: number | null
    type: $Enums.EventType
    created_at: Date
    _count: EventCountAggregateOutputType | null
    _avg: EventAvgAggregateOutputType | null
    _sum: EventSumAggregateOutputType | null
    _min: EventMinAggregateOutputType | null
    _max: EventMaxAggregateOutputType | null
  }

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


  export type EventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    date?: boolean
    location?: boolean
    max_attendees?: boolean
    type?: boolean
    created_at?: boolean
    rsvps?: boolean | Event$rsvpsArgs<ExtArgs>
    _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["event"]>

  export type EventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    date?: boolean
    location?: boolean
    max_attendees?: boolean
    type?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["event"]>

  export type EventSelectScalar = {
    id?: boolean
    title?: boolean
    description?: boolean
    date?: boolean
    location?: boolean
    max_attendees?: boolean
    type?: boolean
    created_at?: boolean
  }

  export type EventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    rsvps?: boolean | Event$rsvpsArgs<ExtArgs>
    _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type EventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $EventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Event"
    objects: {
      rsvps: Prisma.$EventRSVPPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      description: string | null
      date: Date
      location: string
      max_attendees: number | null
      type: $Enums.EventType
      created_at: Date
    }, ExtArgs["result"]["event"]>
    composites: {}
  }

  type EventGetPayload<S extends boolean | null | undefined | EventDefaultArgs> = $Result.GetResult<Prisma.$EventPayload, S>

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

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

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

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

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

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

    /**
     * Create a Event.
     * @param {EventCreateArgs} args - Arguments to create a Event.
     * @example
     * // Create one Event
     * const Event = await prisma.event.create({
     *   data: {
     *     // ... data to create a Event
     *   }
     * })
     * 
     */
    create<T extends EventCreateArgs>(args: SelectSubset<T, EventCreateArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Event.
     * @param {EventDeleteArgs} args - Arguments to delete one Event.
     * @example
     * // Delete one Event
     * const Event = await prisma.event.delete({
     *   where: {
     *     // ... filter to delete one Event
     *   }
     * })
     * 
     */
    delete<T extends EventDeleteArgs>(args: SelectSubset<T, EventDeleteArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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


    /**
     * 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 {EventCountArgs} args - Arguments to filter Events to count.
     * @example
     * // Count the number of Events
     * const count = await prisma.event.count({
     *   where: {
     *     // ... the filter for the Events we want to count
     *   }
     * })
    **/
    count<T extends EventCountArgs>(
      args?: Subset<T, EventCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], EventCountAggregateOutputType>
        : number
    >

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

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

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




  /**
   * Fields of the Event model
   */ 
  interface EventFieldRefs {
    readonly id: FieldRef<"Event", 'String'>
    readonly title: FieldRef<"Event", 'String'>
    readonly description: FieldRef<"Event", 'String'>
    readonly date: FieldRef<"Event", 'DateTime'>
    readonly location: FieldRef<"Event", 'String'>
    readonly max_attendees: FieldRef<"Event", 'Int'>
    readonly type: FieldRef<"Event", 'EventType'>
    readonly created_at: FieldRef<"Event", 'DateTime'>
  }
    

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

  /**
   * Event findUniqueOrThrow
   */
  export type EventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * Filter, which Event to fetch.
     */
    where: EventWhereUniqueInput
  }

  /**
   * Event findFirst
   */
  export type EventFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * Filter, which Event to fetch.
     */
    where?: EventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Events to fetch.
     */
    orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Events.
     */
    cursor?: EventWhereUniqueInput
    /**
     * {@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?: EventScalarFieldEnum | EventScalarFieldEnum[]
  }

  /**
   * Event findFirstOrThrow
   */
  export type EventFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * Filter, which Event to fetch.
     */
    where?: EventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Events to fetch.
     */
    orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Events.
     */
    cursor?: EventWhereUniqueInput
    /**
     * {@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?: EventScalarFieldEnum | EventScalarFieldEnum[]
  }

  /**
   * Event findMany
   */
  export type EventFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * Filter, which Events to fetch.
     */
    where?: EventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Events to fetch.
     */
    orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Events.
     */
    cursor?: EventWhereUniqueInput
    /**
     * {@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?: EventScalarFieldEnum | EventScalarFieldEnum[]
  }

  /**
   * Event create
   */
  export type EventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * The data needed to create a Event.
     */
    data: XOR<EventCreateInput, EventUncheckedCreateInput>
  }

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

  /**
   * Event createManyAndReturn
   */
  export type EventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Events.
     */
    data: EventCreateManyInput | EventCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Event update
   */
  export type EventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * The data needed to update a Event.
     */
    data: XOR<EventUpdateInput, EventUncheckedUpdateInput>
    /**
     * Choose, which Event to update.
     */
    where: EventWhereUniqueInput
  }

  /**
   * Event updateMany
   */
  export type EventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Events.
     */
    data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyInput>
    /**
     * Filter which Events to update
     */
    where?: EventWhereInput
  }

  /**
   * Event upsert
   */
  export type EventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * The filter to search for the Event to update in case it exists.
     */
    where: EventWhereUniqueInput
    /**
     * In case the Event found by the `where` argument doesn't exist, create a new Event with this data.
     */
    create: XOR<EventCreateInput, EventUncheckedCreateInput>
    /**
     * In case the Event was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EventUpdateInput, EventUncheckedUpdateInput>
  }

  /**
   * Event delete
   */
  export type EventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Event
     */
    select?: EventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventInclude<ExtArgs> | null
    /**
     * Filter which Event to delete.
     */
    where: EventWhereUniqueInput
  }

  /**
   * Event deleteMany
   */
  export type EventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Events to delete
     */
    where?: EventWhereInput
  }

  /**
   * Event.rsvps
   */
  export type Event$rsvpsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    where?: EventRSVPWhereInput
    orderBy?: EventRSVPOrderByWithRelationInput | EventRSVPOrderByWithRelationInput[]
    cursor?: EventRSVPWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventRSVPScalarFieldEnum | EventRSVPScalarFieldEnum[]
  }

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


  /**
   * Model EventRSVP
   */

  export type AggregateEventRSVP = {
    _count: EventRSVPCountAggregateOutputType | null
    _min: EventRSVPMinAggregateOutputType | null
    _max: EventRSVPMaxAggregateOutputType | null
  }

  export type EventRSVPMinAggregateOutputType = {
    event_id: string | null
    user_id: string | null
    created_at: Date | null
  }

  export type EventRSVPMaxAggregateOutputType = {
    event_id: string | null
    user_id: string | null
    created_at: Date | null
  }

  export type EventRSVPCountAggregateOutputType = {
    event_id: number
    user_id: number
    created_at: number
    _all: number
  }


  export type EventRSVPMinAggregateInputType = {
    event_id?: true
    user_id?: true
    created_at?: true
  }

  export type EventRSVPMaxAggregateInputType = {
    event_id?: true
    user_id?: true
    created_at?: true
  }

  export type EventRSVPCountAggregateInputType = {
    event_id?: true
    user_id?: true
    created_at?: true
    _all?: true
  }

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

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




  export type EventRSVPGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventRSVPWhereInput
    orderBy?: EventRSVPOrderByWithAggregationInput | EventRSVPOrderByWithAggregationInput[]
    by: EventRSVPScalarFieldEnum[] | EventRSVPScalarFieldEnum
    having?: EventRSVPScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventRSVPCountAggregateInputType | true
    _min?: EventRSVPMinAggregateInputType
    _max?: EventRSVPMaxAggregateInputType
  }

  export type EventRSVPGroupByOutputType = {
    event_id: string
    user_id: string
    created_at: Date
    _count: EventRSVPCountAggregateOutputType | null
    _min: EventRSVPMinAggregateOutputType | null
    _max: EventRSVPMaxAggregateOutputType | null
  }

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


  export type EventRSVPSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    event_id?: boolean
    user_id?: boolean
    created_at?: boolean
    event?: boolean | EventDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["eventRSVP"]>

  export type EventRSVPSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    event_id?: boolean
    user_id?: boolean
    created_at?: boolean
    event?: boolean | EventDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["eventRSVP"]>

  export type EventRSVPSelectScalar = {
    event_id?: boolean
    user_id?: boolean
    created_at?: boolean
  }

  export type EventRSVPInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    event?: boolean | EventDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type EventRSVPIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    event?: boolean | EventDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $EventRSVPPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "EventRSVP"
    objects: {
      event: Prisma.$EventPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      event_id: string
      user_id: string
      created_at: Date
    }, ExtArgs["result"]["eventRSVP"]>
    composites: {}
  }

  type EventRSVPGetPayload<S extends boolean | null | undefined | EventRSVPDefaultArgs> = $Result.GetResult<Prisma.$EventRSVPPayload, S>

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

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

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

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

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

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

    /**
     * Create a EventRSVP.
     * @param {EventRSVPCreateArgs} args - Arguments to create a EventRSVP.
     * @example
     * // Create one EventRSVP
     * const EventRSVP = await prisma.eventRSVP.create({
     *   data: {
     *     // ... data to create a EventRSVP
     *   }
     * })
     * 
     */
    create<T extends EventRSVPCreateArgs>(args: SelectSubset<T, EventRSVPCreateArgs<ExtArgs>>): Prisma__EventRSVPClient<$Result.GetResult<Prisma.$EventRSVPPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Create many EventRSVPS and returns the data saved in the database.
     * @param {EventRSVPCreateManyAndReturnArgs} args - Arguments to create many EventRSVPS.
     * @example
     * // Create many EventRSVPS
     * const eventRSVP = await prisma.eventRSVP.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many EventRSVPS and only return the `event_id`
     * const eventRSVPWithEvent_idOnly = await prisma.eventRSVP.createManyAndReturn({ 
     *   select: { event_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 EventRSVPCreateManyAndReturnArgs>(args?: SelectSubset<T, EventRSVPCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventRSVPPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a EventRSVP.
     * @param {EventRSVPDeleteArgs} args - Arguments to delete one EventRSVP.
     * @example
     * // Delete one EventRSVP
     * const EventRSVP = await prisma.eventRSVP.delete({
     *   where: {
     *     // ... filter to delete one EventRSVP
     *   }
     * })
     * 
     */
    delete<T extends EventRSVPDeleteArgs>(args: SelectSubset<T, EventRSVPDeleteArgs<ExtArgs>>): Prisma__EventRSVPClient<$Result.GetResult<Prisma.$EventRSVPPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the EventRSVP model
   */ 
  interface EventRSVPFieldRefs {
    readonly event_id: FieldRef<"EventRSVP", 'String'>
    readonly user_id: FieldRef<"EventRSVP", 'String'>
    readonly created_at: FieldRef<"EventRSVP", 'DateTime'>
  }
    

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

  /**
   * EventRSVP findUniqueOrThrow
   */
  export type EventRSVPFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    /**
     * Filter, which EventRSVP to fetch.
     */
    where: EventRSVPWhereUniqueInput
  }

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

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

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

  /**
   * EventRSVP create
   */
  export type EventRSVPCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    /**
     * The data needed to create a EventRSVP.
     */
    data: XOR<EventRSVPCreateInput, EventRSVPUncheckedCreateInput>
  }

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

  /**
   * EventRSVP createManyAndReturn
   */
  export type EventRSVPCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many EventRSVPS.
     */
    data: EventRSVPCreateManyInput | EventRSVPCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * EventRSVP update
   */
  export type EventRSVPUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    /**
     * The data needed to update a EventRSVP.
     */
    data: XOR<EventRSVPUpdateInput, EventRSVPUncheckedUpdateInput>
    /**
     * Choose, which EventRSVP to update.
     */
    where: EventRSVPWhereUniqueInput
  }

  /**
   * EventRSVP updateMany
   */
  export type EventRSVPUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update EventRSVPS.
     */
    data: XOR<EventRSVPUpdateManyMutationInput, EventRSVPUncheckedUpdateManyInput>
    /**
     * Filter which EventRSVPS to update
     */
    where?: EventRSVPWhereInput
  }

  /**
   * EventRSVP upsert
   */
  export type EventRSVPUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    /**
     * The filter to search for the EventRSVP to update in case it exists.
     */
    where: EventRSVPWhereUniqueInput
    /**
     * In case the EventRSVP found by the `where` argument doesn't exist, create a new EventRSVP with this data.
     */
    create: XOR<EventRSVPCreateInput, EventRSVPUncheckedCreateInput>
    /**
     * In case the EventRSVP was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EventRSVPUpdateInput, EventRSVPUncheckedUpdateInput>
  }

  /**
   * EventRSVP delete
   */
  export type EventRSVPDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventRSVP
     */
    select?: EventRSVPSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventRSVPInclude<ExtArgs> | null
    /**
     * Filter which EventRSVP to delete.
     */
    where: EventRSVPWhereUniqueInput
  }

  /**
   * EventRSVP deleteMany
   */
  export type EventRSVPDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which EventRSVPS to delete
     */
    where?: EventRSVPWhereInput
  }

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


  /**
   * Model LivestreamSource
   */

  export type AggregateLivestreamSource = {
    _count: LivestreamSourceCountAggregateOutputType | null
    _min: LivestreamSourceMinAggregateOutputType | null
    _max: LivestreamSourceMaxAggregateOutputType | null
  }

  export type LivestreamSourceMinAggregateOutputType = {
    id: string | null
    name: string | null
    stream_url: string | null
    camera_location: string | null
    status: $Enums.StreamStatus | null
    thumbnail_url: string | null
    created_at: Date | null
  }

  export type LivestreamSourceMaxAggregateOutputType = {
    id: string | null
    name: string | null
    stream_url: string | null
    camera_location: string | null
    status: $Enums.StreamStatus | null
    thumbnail_url: string | null
    created_at: Date | null
  }

  export type LivestreamSourceCountAggregateOutputType = {
    id: number
    name: number
    stream_url: number
    camera_location: number
    status: number
    thumbnail_url: number
    created_at: number
    _all: number
  }


  export type LivestreamSourceMinAggregateInputType = {
    id?: true
    name?: true
    stream_url?: true
    camera_location?: true
    status?: true
    thumbnail_url?: true
    created_at?: true
  }

  export type LivestreamSourceMaxAggregateInputType = {
    id?: true
    name?: true
    stream_url?: true
    camera_location?: true
    status?: true
    thumbnail_url?: true
    created_at?: true
  }

  export type LivestreamSourceCountAggregateInputType = {
    id?: true
    name?: true
    stream_url?: true
    camera_location?: true
    status?: true
    thumbnail_url?: true
    created_at?: true
    _all?: true
  }

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

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




  export type LivestreamSourceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LivestreamSourceWhereInput
    orderBy?: LivestreamSourceOrderByWithAggregationInput | LivestreamSourceOrderByWithAggregationInput[]
    by: LivestreamSourceScalarFieldEnum[] | LivestreamSourceScalarFieldEnum
    having?: LivestreamSourceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LivestreamSourceCountAggregateInputType | true
    _min?: LivestreamSourceMinAggregateInputType
    _max?: LivestreamSourceMaxAggregateInputType
  }

  export type LivestreamSourceGroupByOutputType = {
    id: string
    name: string
    stream_url: string
    camera_location: string
    status: $Enums.StreamStatus
    thumbnail_url: string | null
    created_at: Date
    _count: LivestreamSourceCountAggregateOutputType | null
    _min: LivestreamSourceMinAggregateOutputType | null
    _max: LivestreamSourceMaxAggregateOutputType | null
  }

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


  export type LivestreamSourceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    stream_url?: boolean
    camera_location?: boolean
    status?: boolean
    thumbnail_url?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["livestreamSource"]>

  export type LivestreamSourceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    stream_url?: boolean
    camera_location?: boolean
    status?: boolean
    thumbnail_url?: boolean
    created_at?: boolean
  }, ExtArgs["result"]["livestreamSource"]>

  export type LivestreamSourceSelectScalar = {
    id?: boolean
    name?: boolean
    stream_url?: boolean
    camera_location?: boolean
    status?: boolean
    thumbnail_url?: boolean
    created_at?: boolean
  }


  export type $LivestreamSourcePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "LivestreamSource"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      stream_url: string
      camera_location: string
      status: $Enums.StreamStatus
      thumbnail_url: string | null
      created_at: Date
    }, ExtArgs["result"]["livestreamSource"]>
    composites: {}
  }

  type LivestreamSourceGetPayload<S extends boolean | null | undefined | LivestreamSourceDefaultArgs> = $Result.GetResult<Prisma.$LivestreamSourcePayload, S>

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

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

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

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

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

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

    /**
     * Create a LivestreamSource.
     * @param {LivestreamSourceCreateArgs} args - Arguments to create a LivestreamSource.
     * @example
     * // Create one LivestreamSource
     * const LivestreamSource = await prisma.livestreamSource.create({
     *   data: {
     *     // ... data to create a LivestreamSource
     *   }
     * })
     * 
     */
    create<T extends LivestreamSourceCreateArgs>(args: SelectSubset<T, LivestreamSourceCreateArgs<ExtArgs>>): Prisma__LivestreamSourceClient<$Result.GetResult<Prisma.$LivestreamSourcePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a LivestreamSource.
     * @param {LivestreamSourceDeleteArgs} args - Arguments to delete one LivestreamSource.
     * @example
     * // Delete one LivestreamSource
     * const LivestreamSource = await prisma.livestreamSource.delete({
     *   where: {
     *     // ... filter to delete one LivestreamSource
     *   }
     * })
     * 
     */
    delete<T extends LivestreamSourceDeleteArgs>(args: SelectSubset<T, LivestreamSourceDeleteArgs<ExtArgs>>): Prisma__LivestreamSourceClient<$Result.GetResult<Prisma.$LivestreamSourcePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the LivestreamSource model
   */ 
  interface LivestreamSourceFieldRefs {
    readonly id: FieldRef<"LivestreamSource", 'String'>
    readonly name: FieldRef<"LivestreamSource", 'String'>
    readonly stream_url: FieldRef<"LivestreamSource", 'String'>
    readonly camera_location: FieldRef<"LivestreamSource", 'String'>
    readonly status: FieldRef<"LivestreamSource", 'StreamStatus'>
    readonly thumbnail_url: FieldRef<"LivestreamSource", 'String'>
    readonly created_at: FieldRef<"LivestreamSource", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * LivestreamSource findUnique
   */
  export type LivestreamSourceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter, which LivestreamSource to fetch.
     */
    where: LivestreamSourceWhereUniqueInput
  }

  /**
   * LivestreamSource findUniqueOrThrow
   */
  export type LivestreamSourceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter, which LivestreamSource to fetch.
     */
    where: LivestreamSourceWhereUniqueInput
  }

  /**
   * LivestreamSource findFirst
   */
  export type LivestreamSourceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter, which LivestreamSource to fetch.
     */
    where?: LivestreamSourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LivestreamSources to fetch.
     */
    orderBy?: LivestreamSourceOrderByWithRelationInput | LivestreamSourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for LivestreamSources.
     */
    cursor?: LivestreamSourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LivestreamSources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` LivestreamSources.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of LivestreamSources.
     */
    distinct?: LivestreamSourceScalarFieldEnum | LivestreamSourceScalarFieldEnum[]
  }

  /**
   * LivestreamSource findFirstOrThrow
   */
  export type LivestreamSourceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter, which LivestreamSource to fetch.
     */
    where?: LivestreamSourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LivestreamSources to fetch.
     */
    orderBy?: LivestreamSourceOrderByWithRelationInput | LivestreamSourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for LivestreamSources.
     */
    cursor?: LivestreamSourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LivestreamSources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` LivestreamSources.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of LivestreamSources.
     */
    distinct?: LivestreamSourceScalarFieldEnum | LivestreamSourceScalarFieldEnum[]
  }

  /**
   * LivestreamSource findMany
   */
  export type LivestreamSourceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter, which LivestreamSources to fetch.
     */
    where?: LivestreamSourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LivestreamSources to fetch.
     */
    orderBy?: LivestreamSourceOrderByWithRelationInput | LivestreamSourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing LivestreamSources.
     */
    cursor?: LivestreamSourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LivestreamSources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` LivestreamSources.
     */
    skip?: number
    distinct?: LivestreamSourceScalarFieldEnum | LivestreamSourceScalarFieldEnum[]
  }

  /**
   * LivestreamSource create
   */
  export type LivestreamSourceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * The data needed to create a LivestreamSource.
     */
    data: XOR<LivestreamSourceCreateInput, LivestreamSourceUncheckedCreateInput>
  }

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

  /**
   * LivestreamSource createManyAndReturn
   */
  export type LivestreamSourceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many LivestreamSources.
     */
    data: LivestreamSourceCreateManyInput | LivestreamSourceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * LivestreamSource update
   */
  export type LivestreamSourceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * The data needed to update a LivestreamSource.
     */
    data: XOR<LivestreamSourceUpdateInput, LivestreamSourceUncheckedUpdateInput>
    /**
     * Choose, which LivestreamSource to update.
     */
    where: LivestreamSourceWhereUniqueInput
  }

  /**
   * LivestreamSource updateMany
   */
  export type LivestreamSourceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update LivestreamSources.
     */
    data: XOR<LivestreamSourceUpdateManyMutationInput, LivestreamSourceUncheckedUpdateManyInput>
    /**
     * Filter which LivestreamSources to update
     */
    where?: LivestreamSourceWhereInput
  }

  /**
   * LivestreamSource upsert
   */
  export type LivestreamSourceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * The filter to search for the LivestreamSource to update in case it exists.
     */
    where: LivestreamSourceWhereUniqueInput
    /**
     * In case the LivestreamSource found by the `where` argument doesn't exist, create a new LivestreamSource with this data.
     */
    create: XOR<LivestreamSourceCreateInput, LivestreamSourceUncheckedCreateInput>
    /**
     * In case the LivestreamSource was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LivestreamSourceUpdateInput, LivestreamSourceUncheckedUpdateInput>
  }

  /**
   * LivestreamSource delete
   */
  export type LivestreamSourceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
    /**
     * Filter which LivestreamSource to delete.
     */
    where: LivestreamSourceWhereUniqueInput
  }

  /**
   * LivestreamSource deleteMany
   */
  export type LivestreamSourceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LivestreamSources to delete
     */
    where?: LivestreamSourceWhereInput
  }

  /**
   * LivestreamSource without action
   */
  export type LivestreamSourceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LivestreamSource
     */
    select?: LivestreamSourceSelect<ExtArgs> | null
  }


  /**
   * Model VolunteerHour
   */

  export type AggregateVolunteerHour = {
    _count: VolunteerHourCountAggregateOutputType | null
    _avg: VolunteerHourAvgAggregateOutputType | null
    _sum: VolunteerHourSumAggregateOutputType | null
    _min: VolunteerHourMinAggregateOutputType | null
    _max: VolunteerHourMaxAggregateOutputType | null
  }

  export type VolunteerHourAvgAggregateOutputType = {
    hours: number | null
  }

  export type VolunteerHourSumAggregateOutputType = {
    hours: number | null
  }

  export type VolunteerHourMinAggregateOutputType = {
    id: string | null
    volunteer_id: string | null
    date: Date | null
    hours: number | null
    task_description: string | null
    verified_by: string | null
    created_at: Date | null
  }

  export type VolunteerHourMaxAggregateOutputType = {
    id: string | null
    volunteer_id: string | null
    date: Date | null
    hours: number | null
    task_description: string | null
    verified_by: string | null
    created_at: Date | null
  }

  export type VolunteerHourCountAggregateOutputType = {
    id: number
    volunteer_id: number
    date: number
    hours: number
    task_description: number
    verified_by: number
    created_at: number
    _all: number
  }


  export type VolunteerHourAvgAggregateInputType = {
    hours?: true
  }

  export type VolunteerHourSumAggregateInputType = {
    hours?: true
  }

  export type VolunteerHourMinAggregateInputType = {
    id?: true
    volunteer_id?: true
    date?: true
    hours?: true
    task_description?: true
    verified_by?: true
    created_at?: true
  }

  export type VolunteerHourMaxAggregateInputType = {
    id?: true
    volunteer_id?: true
    date?: true
    hours?: true
    task_description?: true
    verified_by?: true
    created_at?: true
  }

  export type VolunteerHourCountAggregateInputType = {
    id?: true
    volunteer_id?: true
    date?: true
    hours?: true
    task_description?: true
    verified_by?: true
    created_at?: true
    _all?: true
  }

  export type VolunteerHourAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VolunteerHour to aggregate.
     */
    where?: VolunteerHourWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VolunteerHours to fetch.
     */
    orderBy?: VolunteerHourOrderByWithRelationInput | VolunteerHourOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: VolunteerHourWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VolunteerHours from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` VolunteerHours.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned VolunteerHours
    **/
    _count?: true | VolunteerHourCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: VolunteerHourAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: VolunteerHourSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VolunteerHourMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VolunteerHourMaxAggregateInputType
  }

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




  export type VolunteerHourGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VolunteerHourWhereInput
    orderBy?: VolunteerHourOrderByWithAggregationInput | VolunteerHourOrderByWithAggregationInput[]
    by: VolunteerHourScalarFieldEnum[] | VolunteerHourScalarFieldEnum
    having?: VolunteerHourScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VolunteerHourCountAggregateInputType | true
    _avg?: VolunteerHourAvgAggregateInputType
    _sum?: VolunteerHourSumAggregateInputType
    _min?: VolunteerHourMinAggregateInputType
    _max?: VolunteerHourMaxAggregateInputType
  }

  export type VolunteerHourGroupByOutputType = {
    id: string
    volunteer_id: string
    date: Date
    hours: number
    task_description: string
    verified_by: string | null
    created_at: Date
    _count: VolunteerHourCountAggregateOutputType | null
    _avg: VolunteerHourAvgAggregateOutputType | null
    _sum: VolunteerHourSumAggregateOutputType | null
    _min: VolunteerHourMinAggregateOutputType | null
    _max: VolunteerHourMaxAggregateOutputType | null
  }

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


  export type VolunteerHourSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    volunteer_id?: boolean
    date?: boolean
    hours?: boolean
    task_description?: boolean
    verified_by?: boolean
    created_at?: boolean
    volunteer?: boolean | UserDefaultArgs<ExtArgs>
    verifier?: boolean | VolunteerHour$verifierArgs<ExtArgs>
  }, ExtArgs["result"]["volunteerHour"]>

  export type VolunteerHourSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    volunteer_id?: boolean
    date?: boolean
    hours?: boolean
    task_description?: boolean
    verified_by?: boolean
    created_at?: boolean
    volunteer?: boolean | UserDefaultArgs<ExtArgs>
    verifier?: boolean | VolunteerHour$verifierArgs<ExtArgs>
  }, ExtArgs["result"]["volunteerHour"]>

  export type VolunteerHourSelectScalar = {
    id?: boolean
    volunteer_id?: boolean
    date?: boolean
    hours?: boolean
    task_description?: boolean
    verified_by?: boolean
    created_at?: boolean
  }

  export type VolunteerHourInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    volunteer?: boolean | UserDefaultArgs<ExtArgs>
    verifier?: boolean | VolunteerHour$verifierArgs<ExtArgs>
  }
  export type VolunteerHourIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    volunteer?: boolean | UserDefaultArgs<ExtArgs>
    verifier?: boolean | VolunteerHour$verifierArgs<ExtArgs>
  }

  export type $VolunteerHourPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "VolunteerHour"
    objects: {
      volunteer: Prisma.$UserPayload<ExtArgs>
      verifier: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      volunteer_id: string
      date: Date
      hours: number
      task_description: string
      verified_by: string | null
      created_at: Date
    }, ExtArgs["result"]["volunteerHour"]>
    composites: {}
  }

  type VolunteerHourGetPayload<S extends boolean | null | undefined | VolunteerHourDefaultArgs> = $Result.GetResult<Prisma.$VolunteerHourPayload, S>

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

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

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

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

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

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

    /**
     * Create a VolunteerHour.
     * @param {VolunteerHourCreateArgs} args - Arguments to create a VolunteerHour.
     * @example
     * // Create one VolunteerHour
     * const VolunteerHour = await prisma.volunteerHour.create({
     *   data: {
     *     // ... data to create a VolunteerHour
     *   }
     * })
     * 
     */
    create<T extends VolunteerHourCreateArgs>(args: SelectSubset<T, VolunteerHourCreateArgs<ExtArgs>>): Prisma__VolunteerHourClient<$Result.GetResult<Prisma.$VolunteerHourPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a VolunteerHour.
     * @param {VolunteerHourDeleteArgs} args - Arguments to delete one VolunteerHour.
     * @example
     * // Delete one VolunteerHour
     * const VolunteerHour = await prisma.volunteerHour.delete({
     *   where: {
     *     // ... filter to delete one VolunteerHour
     *   }
     * })
     * 
     */
    delete<T extends VolunteerHourDeleteArgs>(args: SelectSubset<T, VolunteerHourDeleteArgs<ExtArgs>>): Prisma__VolunteerHourClient<$Result.GetResult<Prisma.$VolunteerHourPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the VolunteerHour model
   */ 
  interface VolunteerHourFieldRefs {
    readonly id: FieldRef<"VolunteerHour", 'String'>
    readonly volunteer_id: FieldRef<"VolunteerHour", 'String'>
    readonly date: FieldRef<"VolunteerHour", 'DateTime'>
    readonly hours: FieldRef<"VolunteerHour", 'Float'>
    readonly task_description: FieldRef<"VolunteerHour", 'String'>
    readonly verified_by: FieldRef<"VolunteerHour", 'String'>
    readonly created_at: FieldRef<"VolunteerHour", 'DateTime'>
  }
    

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

  /**
   * VolunteerHour findUniqueOrThrow
   */
  export type VolunteerHourFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    /**
     * Filter, which VolunteerHour to fetch.
     */
    where: VolunteerHourWhereUniqueInput
  }

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

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

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

  /**
   * VolunteerHour create
   */
  export type VolunteerHourCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    /**
     * The data needed to create a VolunteerHour.
     */
    data: XOR<VolunteerHourCreateInput, VolunteerHourUncheckedCreateInput>
  }

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

  /**
   * VolunteerHour createManyAndReturn
   */
  export type VolunteerHourCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many VolunteerHours.
     */
    data: VolunteerHourCreateManyInput | VolunteerHourCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * VolunteerHour update
   */
  export type VolunteerHourUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    /**
     * The data needed to update a VolunteerHour.
     */
    data: XOR<VolunteerHourUpdateInput, VolunteerHourUncheckedUpdateInput>
    /**
     * Choose, which VolunteerHour to update.
     */
    where: VolunteerHourWhereUniqueInput
  }

  /**
   * VolunteerHour updateMany
   */
  export type VolunteerHourUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update VolunteerHours.
     */
    data: XOR<VolunteerHourUpdateManyMutationInput, VolunteerHourUncheckedUpdateManyInput>
    /**
     * Filter which VolunteerHours to update
     */
    where?: VolunteerHourWhereInput
  }

  /**
   * VolunteerHour upsert
   */
  export type VolunteerHourUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    /**
     * The filter to search for the VolunteerHour to update in case it exists.
     */
    where: VolunteerHourWhereUniqueInput
    /**
     * In case the VolunteerHour found by the `where` argument doesn't exist, create a new VolunteerHour with this data.
     */
    create: XOR<VolunteerHourCreateInput, VolunteerHourUncheckedCreateInput>
    /**
     * In case the VolunteerHour was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VolunteerHourUpdateInput, VolunteerHourUncheckedUpdateInput>
  }

  /**
   * VolunteerHour delete
   */
  export type VolunteerHourDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VolunteerHour
     */
    select?: VolunteerHourSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VolunteerHourInclude<ExtArgs> | null
    /**
     * Filter which VolunteerHour to delete.
     */
    where: VolunteerHourWhereUniqueInput
  }

  /**
   * VolunteerHour deleteMany
   */
  export type VolunteerHourDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VolunteerHours to delete
     */
    where?: VolunteerHourWhereInput
  }

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

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


  /**
   * Model EquipmentItem
   */

  export type AggregateEquipmentItem = {
    _count: EquipmentItemCountAggregateOutputType | null
    _min: EquipmentItemMinAggregateOutputType | null
    _max: EquipmentItemMaxAggregateOutputType | null
  }

  export type EquipmentItemMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    status: $Enums.EquipmentStatus | null
    checked_out_by: string | null
    checked_out_at: Date | null
    created_at: Date | null
  }

  export type EquipmentItemMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    status: $Enums.EquipmentStatus | null
    checked_out_by: string | null
    checked_out_at: Date | null
    created_at: Date | null
  }

  export type EquipmentItemCountAggregateOutputType = {
    id: number
    name: number
    description: number
    status: number
    checked_out_by: number
    checked_out_at: number
    created_at: number
    _all: number
  }


  export type EquipmentItemMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    status?: true
    checked_out_by?: true
    checked_out_at?: true
    created_at?: true
  }

  export type EquipmentItemMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    status?: true
    checked_out_by?: true
    checked_out_at?: true
    created_at?: true
  }

  export type EquipmentItemCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    status?: true
    checked_out_by?: true
    checked_out_at?: true
    created_at?: true
    _all?: true
  }

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

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




  export type EquipmentItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EquipmentItemWhereInput
    orderBy?: EquipmentItemOrderByWithAggregationInput | EquipmentItemOrderByWithAggregationInput[]
    by: EquipmentItemScalarFieldEnum[] | EquipmentItemScalarFieldEnum
    having?: EquipmentItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EquipmentItemCountAggregateInputType | true
    _min?: EquipmentItemMinAggregateInputType
    _max?: EquipmentItemMaxAggregateInputType
  }

  export type EquipmentItemGroupByOutputType = {
    id: string
    name: string
    description: string | null
    status: $Enums.EquipmentStatus
    checked_out_by: string | null
    checked_out_at: Date | null
    created_at: Date
    _count: EquipmentItemCountAggregateOutputType | null
    _min: EquipmentItemMinAggregateOutputType | null
    _max: EquipmentItemMaxAggregateOutputType | null
  }

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


  export type EquipmentItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    status?: boolean
    checked_out_by?: boolean
    checked_out_at?: boolean
    created_at?: boolean
    checker?: boolean | EquipmentItem$checkerArgs<ExtArgs>
  }, ExtArgs["result"]["equipmentItem"]>

  export type EquipmentItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    status?: boolean
    checked_out_by?: boolean
    checked_out_at?: boolean
    created_at?: boolean
    checker?: boolean | EquipmentItem$checkerArgs<ExtArgs>
  }, ExtArgs["result"]["equipmentItem"]>

  export type EquipmentItemSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    status?: boolean
    checked_out_by?: boolean
    checked_out_at?: boolean
    created_at?: boolean
  }

  export type EquipmentItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    checker?: boolean | EquipmentItem$checkerArgs<ExtArgs>
  }
  export type EquipmentItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    checker?: boolean | EquipmentItem$checkerArgs<ExtArgs>
  }

  export type $EquipmentItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "EquipmentItem"
    objects: {
      checker: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      status: $Enums.EquipmentStatus
      checked_out_by: string | null
      checked_out_at: Date | null
      created_at: Date
    }, ExtArgs["result"]["equipmentItem"]>
    composites: {}
  }

  type EquipmentItemGetPayload<S extends boolean | null | undefined | EquipmentItemDefaultArgs> = $Result.GetResult<Prisma.$EquipmentItemPayload, S>

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

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

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

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

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

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

    /**
     * Create a EquipmentItem.
     * @param {EquipmentItemCreateArgs} args - Arguments to create a EquipmentItem.
     * @example
     * // Create one EquipmentItem
     * const EquipmentItem = await prisma.equipmentItem.create({
     *   data: {
     *     // ... data to create a EquipmentItem
     *   }
     * })
     * 
     */
    create<T extends EquipmentItemCreateArgs>(args: SelectSubset<T, EquipmentItemCreateArgs<ExtArgs>>): Prisma__EquipmentItemClient<$Result.GetResult<Prisma.$EquipmentItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a EquipmentItem.
     * @param {EquipmentItemDeleteArgs} args - Arguments to delete one EquipmentItem.
     * @example
     * // Delete one EquipmentItem
     * const EquipmentItem = await prisma.equipmentItem.delete({
     *   where: {
     *     // ... filter to delete one EquipmentItem
     *   }
     * })
     * 
     */
    delete<T extends EquipmentItemDeleteArgs>(args: SelectSubset<T, EquipmentItemDeleteArgs<ExtArgs>>): Prisma__EquipmentItemClient<$Result.GetResult<Prisma.$EquipmentItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the EquipmentItem model
   */ 
  interface EquipmentItemFieldRefs {
    readonly id: FieldRef<"EquipmentItem", 'String'>
    readonly name: FieldRef<"EquipmentItem", 'String'>
    readonly description: FieldRef<"EquipmentItem", 'String'>
    readonly status: FieldRef<"EquipmentItem", 'EquipmentStatus'>
    readonly checked_out_by: FieldRef<"EquipmentItem", 'String'>
    readonly checked_out_at: FieldRef<"EquipmentItem", 'DateTime'>
    readonly created_at: FieldRef<"EquipmentItem", 'DateTime'>
  }
    

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

  /**
   * EquipmentItem findUniqueOrThrow
   */
  export type EquipmentItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    /**
     * Filter, which EquipmentItem to fetch.
     */
    where: EquipmentItemWhereUniqueInput
  }

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

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

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

  /**
   * EquipmentItem create
   */
  export type EquipmentItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    /**
     * The data needed to create a EquipmentItem.
     */
    data: XOR<EquipmentItemCreateInput, EquipmentItemUncheckedCreateInput>
  }

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

  /**
   * EquipmentItem createManyAndReturn
   */
  export type EquipmentItemCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many EquipmentItems.
     */
    data: EquipmentItemCreateManyInput | EquipmentItemCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * EquipmentItem update
   */
  export type EquipmentItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    /**
     * The data needed to update a EquipmentItem.
     */
    data: XOR<EquipmentItemUpdateInput, EquipmentItemUncheckedUpdateInput>
    /**
     * Choose, which EquipmentItem to update.
     */
    where: EquipmentItemWhereUniqueInput
  }

  /**
   * EquipmentItem updateMany
   */
  export type EquipmentItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update EquipmentItems.
     */
    data: XOR<EquipmentItemUpdateManyMutationInput, EquipmentItemUncheckedUpdateManyInput>
    /**
     * Filter which EquipmentItems to update
     */
    where?: EquipmentItemWhereInput
  }

  /**
   * EquipmentItem upsert
   */
  export type EquipmentItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    /**
     * The filter to search for the EquipmentItem to update in case it exists.
     */
    where: EquipmentItemWhereUniqueInput
    /**
     * In case the EquipmentItem found by the `where` argument doesn't exist, create a new EquipmentItem with this data.
     */
    create: XOR<EquipmentItemCreateInput, EquipmentItemUncheckedCreateInput>
    /**
     * In case the EquipmentItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EquipmentItemUpdateInput, EquipmentItemUncheckedUpdateInput>
  }

  /**
   * EquipmentItem delete
   */
  export type EquipmentItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EquipmentItem
     */
    select?: EquipmentItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentItemInclude<ExtArgs> | null
    /**
     * Filter which EquipmentItem to delete.
     */
    where: EquipmentItemWhereUniqueInput
  }

  /**
   * EquipmentItem deleteMany
   */
  export type EquipmentItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which EquipmentItems to delete
     */
    where?: EquipmentItemWhereInput
  }

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

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


  /**
   * Enums
   */

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

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


  export const UserScalarFieldEnum: {
    id: 'id',
    email: 'email',
    name: 'name',
    role: 'role',
    password_hash: 'password_hash',
    created_at: 'created_at'
  };

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


  export const BurrowScalarFieldEnum: {
    id: 'id',
    gps_lat: 'gps_lat',
    gps_lng: 'gps_lng',
    status: 'status',
    location_description: 'location_description',
    photos: 'photos',
    assigned_volunteer_id: 'assigned_volunteer_id',
    created_at: 'created_at'
  };

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


  export const DonationScalarFieldEnum: {
    id: 'id',
    donor_id: 'donor_id',
    amount: 'amount',
    campaign: 'campaign',
    stripe_payment_id: 'stripe_payment_id',
    created_at: 'created_at'
  };

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


  export const WildlifeSightingScalarFieldEnum: {
    id: 'id',
    reporter_id: 'reporter_id',
    species: 'species',
    gps_lat: 'gps_lat',
    gps_lng: 'gps_lng',
    photo_url: 'photo_url',
    description: 'description',
    verified: 'verified',
    created_at: 'created_at'
  };

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


  export const EventScalarFieldEnum: {
    id: 'id',
    title: 'title',
    description: 'description',
    date: 'date',
    location: 'location',
    max_attendees: 'max_attendees',
    type: 'type',
    created_at: 'created_at'
  };

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


  export const EventRSVPScalarFieldEnum: {
    event_id: 'event_id',
    user_id: 'user_id',
    created_at: 'created_at'
  };

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


  export const LivestreamSourceScalarFieldEnum: {
    id: 'id',
    name: 'name',
    stream_url: 'stream_url',
    camera_location: 'camera_location',
    status: 'status',
    thumbnail_url: 'thumbnail_url',
    created_at: 'created_at'
  };

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


  export const VolunteerHourScalarFieldEnum: {
    id: 'id',
    volunteer_id: 'volunteer_id',
    date: 'date',
    hours: 'hours',
    task_description: 'task_description',
    verified_by: 'verified_by',
    created_at: 'created_at'
  };

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


  export const EquipmentItemScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    status: 'status',
    checked_out_by: 'checked_out_by',
    checked_out_at: 'checked_out_at',
    created_at: 'created_at'
  };

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


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

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


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

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


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

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


  /**
   * Field references 
   */


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


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


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


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


  /**
   * Reference to a field of type '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 '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 'BurrowStatus'
   */
  export type EnumBurrowStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BurrowStatus'>
    


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


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


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


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


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


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


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


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


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


  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    name?: StringFilter<"User"> | string
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    password_hash?: StringFilter<"User"> | string
    created_at?: DateTimeFilter<"User"> | Date | string
    burrows?: BurrowListRelationFilter
    donations?: DonationListRelationFilter
    sightings?: WildlifeSightingListRelationFilter
    event_rsvps?: EventRSVPListRelationFilter
    volunteer_hours?: VolunteerHourListRelationFilter
    equipment_items?: EquipmentItemListRelationFilter
    verified_hours?: VolunteerHourListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    role?: SortOrder
    password_hash?: SortOrder
    created_at?: SortOrder
    burrows?: BurrowOrderByRelationAggregateInput
    donations?: DonationOrderByRelationAggregateInput
    sightings?: WildlifeSightingOrderByRelationAggregateInput
    event_rsvps?: EventRSVPOrderByRelationAggregateInput
    volunteer_hours?: VolunteerHourOrderByRelationAggregateInput
    equipment_items?: EquipmentItemOrderByRelationAggregateInput
    verified_hours?: VolunteerHourOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    name?: StringFilter<"User"> | string
    role?: EnumUserRoleFilter<"User"> | $Enums.UserRole
    password_hash?: StringFilter<"User"> | string
    created_at?: DateTimeFilter<"User"> | Date | string
    burrows?: BurrowListRelationFilter
    donations?: DonationListRelationFilter
    sightings?: WildlifeSightingListRelationFilter
    event_rsvps?: EventRSVPListRelationFilter
    volunteer_hours?: VolunteerHourListRelationFilter
    equipment_items?: EquipmentItemListRelationFilter
    verified_hours?: VolunteerHourListRelationFilter
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    role?: SortOrder
    password_hash?: SortOrder
    created_at?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    name?: StringWithAggregatesFilter<"User"> | string
    role?: EnumUserRoleWithAggregatesFilter<"User"> | $Enums.UserRole
    password_hash?: StringWithAggregatesFilter<"User"> | string
    created_at?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type BurrowWhereInput = {
    AND?: BurrowWhereInput | BurrowWhereInput[]
    OR?: BurrowWhereInput[]
    NOT?: BurrowWhereInput | BurrowWhereInput[]
    id?: StringFilter<"Burrow"> | string
    gps_lat?: FloatFilter<"Burrow"> | number
    gps_lng?: FloatFilter<"Burrow"> | number
    status?: EnumBurrowStatusFilter<"Burrow"> | $Enums.BurrowStatus
    location_description?: StringNullableFilter<"Burrow"> | string | null
    photos?: StringNullableListFilter<"Burrow">
    assigned_volunteer_id?: StringNullableFilter<"Burrow"> | string | null
    created_at?: DateTimeFilter<"Burrow"> | Date | string
    assigned_volunteer?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type BurrowOrderByWithRelationInput = {
    id?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    status?: SortOrder
    location_description?: SortOrderInput | SortOrder
    photos?: SortOrder
    assigned_volunteer_id?: SortOrderInput | SortOrder
    created_at?: SortOrder
    assigned_volunteer?: UserOrderByWithRelationInput
  }

  export type BurrowWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BurrowWhereInput | BurrowWhereInput[]
    OR?: BurrowWhereInput[]
    NOT?: BurrowWhereInput | BurrowWhereInput[]
    gps_lat?: FloatFilter<"Burrow"> | number
    gps_lng?: FloatFilter<"Burrow"> | number
    status?: EnumBurrowStatusFilter<"Burrow"> | $Enums.BurrowStatus
    location_description?: StringNullableFilter<"Burrow"> | string | null
    photos?: StringNullableListFilter<"Burrow">
    assigned_volunteer_id?: StringNullableFilter<"Burrow"> | string | null
    created_at?: DateTimeFilter<"Burrow"> | Date | string
    assigned_volunteer?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type BurrowOrderByWithAggregationInput = {
    id?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    status?: SortOrder
    location_description?: SortOrderInput | SortOrder
    photos?: SortOrder
    assigned_volunteer_id?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: BurrowCountOrderByAggregateInput
    _avg?: BurrowAvgOrderByAggregateInput
    _max?: BurrowMaxOrderByAggregateInput
    _min?: BurrowMinOrderByAggregateInput
    _sum?: BurrowSumOrderByAggregateInput
  }

  export type BurrowScalarWhereWithAggregatesInput = {
    AND?: BurrowScalarWhereWithAggregatesInput | BurrowScalarWhereWithAggregatesInput[]
    OR?: BurrowScalarWhereWithAggregatesInput[]
    NOT?: BurrowScalarWhereWithAggregatesInput | BurrowScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Burrow"> | string
    gps_lat?: FloatWithAggregatesFilter<"Burrow"> | number
    gps_lng?: FloatWithAggregatesFilter<"Burrow"> | number
    status?: EnumBurrowStatusWithAggregatesFilter<"Burrow"> | $Enums.BurrowStatus
    location_description?: StringNullableWithAggregatesFilter<"Burrow"> | string | null
    photos?: StringNullableListFilter<"Burrow">
    assigned_volunteer_id?: StringNullableWithAggregatesFilter<"Burrow"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"Burrow"> | Date | string
  }

  export type DonationWhereInput = {
    AND?: DonationWhereInput | DonationWhereInput[]
    OR?: DonationWhereInput[]
    NOT?: DonationWhereInput | DonationWhereInput[]
    id?: StringFilter<"Donation"> | string
    donor_id?: StringNullableFilter<"Donation"> | string | null
    amount?: FloatFilter<"Donation"> | number
    campaign?: EnumDonationCampaignFilter<"Donation"> | $Enums.DonationCampaign
    stripe_payment_id?: StringNullableFilter<"Donation"> | string | null
    created_at?: DateTimeFilter<"Donation"> | Date | string
    donor?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type DonationOrderByWithRelationInput = {
    id?: SortOrder
    donor_id?: SortOrderInput | SortOrder
    amount?: SortOrder
    campaign?: SortOrder
    stripe_payment_id?: SortOrderInput | SortOrder
    created_at?: SortOrder
    donor?: UserOrderByWithRelationInput
  }

  export type DonationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: DonationWhereInput | DonationWhereInput[]
    OR?: DonationWhereInput[]
    NOT?: DonationWhereInput | DonationWhereInput[]
    donor_id?: StringNullableFilter<"Donation"> | string | null
    amount?: FloatFilter<"Donation"> | number
    campaign?: EnumDonationCampaignFilter<"Donation"> | $Enums.DonationCampaign
    stripe_payment_id?: StringNullableFilter<"Donation"> | string | null
    created_at?: DateTimeFilter<"Donation"> | Date | string
    donor?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type DonationOrderByWithAggregationInput = {
    id?: SortOrder
    donor_id?: SortOrderInput | SortOrder
    amount?: SortOrder
    campaign?: SortOrder
    stripe_payment_id?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: DonationCountOrderByAggregateInput
    _avg?: DonationAvgOrderByAggregateInput
    _max?: DonationMaxOrderByAggregateInput
    _min?: DonationMinOrderByAggregateInput
    _sum?: DonationSumOrderByAggregateInput
  }

  export type DonationScalarWhereWithAggregatesInput = {
    AND?: DonationScalarWhereWithAggregatesInput | DonationScalarWhereWithAggregatesInput[]
    OR?: DonationScalarWhereWithAggregatesInput[]
    NOT?: DonationScalarWhereWithAggregatesInput | DonationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Donation"> | string
    donor_id?: StringNullableWithAggregatesFilter<"Donation"> | string | null
    amount?: FloatWithAggregatesFilter<"Donation"> | number
    campaign?: EnumDonationCampaignWithAggregatesFilter<"Donation"> | $Enums.DonationCampaign
    stripe_payment_id?: StringNullableWithAggregatesFilter<"Donation"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"Donation"> | Date | string
  }

  export type WildlifeSightingWhereInput = {
    AND?: WildlifeSightingWhereInput | WildlifeSightingWhereInput[]
    OR?: WildlifeSightingWhereInput[]
    NOT?: WildlifeSightingWhereInput | WildlifeSightingWhereInput[]
    id?: StringFilter<"WildlifeSighting"> | string
    reporter_id?: StringNullableFilter<"WildlifeSighting"> | string | null
    species?: StringFilter<"WildlifeSighting"> | string
    gps_lat?: FloatFilter<"WildlifeSighting"> | number
    gps_lng?: FloatFilter<"WildlifeSighting"> | number
    photo_url?: StringNullableFilter<"WildlifeSighting"> | string | null
    description?: StringNullableFilter<"WildlifeSighting"> | string | null
    verified?: BoolFilter<"WildlifeSighting"> | boolean
    created_at?: DateTimeFilter<"WildlifeSighting"> | Date | string
    reporter?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type WildlifeSightingOrderByWithRelationInput = {
    id?: SortOrder
    reporter_id?: SortOrderInput | SortOrder
    species?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    photo_url?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    verified?: SortOrder
    created_at?: SortOrder
    reporter?: UserOrderByWithRelationInput
  }

  export type WildlifeSightingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: WildlifeSightingWhereInput | WildlifeSightingWhereInput[]
    OR?: WildlifeSightingWhereInput[]
    NOT?: WildlifeSightingWhereInput | WildlifeSightingWhereInput[]
    reporter_id?: StringNullableFilter<"WildlifeSighting"> | string | null
    species?: StringFilter<"WildlifeSighting"> | string
    gps_lat?: FloatFilter<"WildlifeSighting"> | number
    gps_lng?: FloatFilter<"WildlifeSighting"> | number
    photo_url?: StringNullableFilter<"WildlifeSighting"> | string | null
    description?: StringNullableFilter<"WildlifeSighting"> | string | null
    verified?: BoolFilter<"WildlifeSighting"> | boolean
    created_at?: DateTimeFilter<"WildlifeSighting"> | Date | string
    reporter?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type WildlifeSightingOrderByWithAggregationInput = {
    id?: SortOrder
    reporter_id?: SortOrderInput | SortOrder
    species?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    photo_url?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    verified?: SortOrder
    created_at?: SortOrder
    _count?: WildlifeSightingCountOrderByAggregateInput
    _avg?: WildlifeSightingAvgOrderByAggregateInput
    _max?: WildlifeSightingMaxOrderByAggregateInput
    _min?: WildlifeSightingMinOrderByAggregateInput
    _sum?: WildlifeSightingSumOrderByAggregateInput
  }

  export type WildlifeSightingScalarWhereWithAggregatesInput = {
    AND?: WildlifeSightingScalarWhereWithAggregatesInput | WildlifeSightingScalarWhereWithAggregatesInput[]
    OR?: WildlifeSightingScalarWhereWithAggregatesInput[]
    NOT?: WildlifeSightingScalarWhereWithAggregatesInput | WildlifeSightingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WildlifeSighting"> | string
    reporter_id?: StringNullableWithAggregatesFilter<"WildlifeSighting"> | string | null
    species?: StringWithAggregatesFilter<"WildlifeSighting"> | string
    gps_lat?: FloatWithAggregatesFilter<"WildlifeSighting"> | number
    gps_lng?: FloatWithAggregatesFilter<"WildlifeSighting"> | number
    photo_url?: StringNullableWithAggregatesFilter<"WildlifeSighting"> | string | null
    description?: StringNullableWithAggregatesFilter<"WildlifeSighting"> | string | null
    verified?: BoolWithAggregatesFilter<"WildlifeSighting"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"WildlifeSighting"> | Date | string
  }

  export type EventWhereInput = {
    AND?: EventWhereInput | EventWhereInput[]
    OR?: EventWhereInput[]
    NOT?: EventWhereInput | EventWhereInput[]
    id?: StringFilter<"Event"> | string
    title?: StringFilter<"Event"> | string
    description?: StringNullableFilter<"Event"> | string | null
    date?: DateTimeFilter<"Event"> | Date | string
    location?: StringFilter<"Event"> | string
    max_attendees?: IntNullableFilter<"Event"> | number | null
    type?: EnumEventTypeFilter<"Event"> | $Enums.EventType
    created_at?: DateTimeFilter<"Event"> | Date | string
    rsvps?: EventRSVPListRelationFilter
  }

  export type EventOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    date?: SortOrder
    location?: SortOrder
    max_attendees?: SortOrderInput | SortOrder
    type?: SortOrder
    created_at?: SortOrder
    rsvps?: EventRSVPOrderByRelationAggregateInput
  }

  export type EventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EventWhereInput | EventWhereInput[]
    OR?: EventWhereInput[]
    NOT?: EventWhereInput | EventWhereInput[]
    title?: StringFilter<"Event"> | string
    description?: StringNullableFilter<"Event"> | string | null
    date?: DateTimeFilter<"Event"> | Date | string
    location?: StringFilter<"Event"> | string
    max_attendees?: IntNullableFilter<"Event"> | number | null
    type?: EnumEventTypeFilter<"Event"> | $Enums.EventType
    created_at?: DateTimeFilter<"Event"> | Date | string
    rsvps?: EventRSVPListRelationFilter
  }, "id">

  export type EventOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    date?: SortOrder
    location?: SortOrder
    max_attendees?: SortOrderInput | SortOrder
    type?: SortOrder
    created_at?: SortOrder
    _count?: EventCountOrderByAggregateInput
    _avg?: EventAvgOrderByAggregateInput
    _max?: EventMaxOrderByAggregateInput
    _min?: EventMinOrderByAggregateInput
    _sum?: EventSumOrderByAggregateInput
  }

  export type EventScalarWhereWithAggregatesInput = {
    AND?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
    OR?: EventScalarWhereWithAggregatesInput[]
    NOT?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Event"> | string
    title?: StringWithAggregatesFilter<"Event"> | string
    description?: StringNullableWithAggregatesFilter<"Event"> | string | null
    date?: DateTimeWithAggregatesFilter<"Event"> | Date | string
    location?: StringWithAggregatesFilter<"Event"> | string
    max_attendees?: IntNullableWithAggregatesFilter<"Event"> | number | null
    type?: EnumEventTypeWithAggregatesFilter<"Event"> | $Enums.EventType
    created_at?: DateTimeWithAggregatesFilter<"Event"> | Date | string
  }

  export type EventRSVPWhereInput = {
    AND?: EventRSVPWhereInput | EventRSVPWhereInput[]
    OR?: EventRSVPWhereInput[]
    NOT?: EventRSVPWhereInput | EventRSVPWhereInput[]
    event_id?: StringFilter<"EventRSVP"> | string
    user_id?: StringFilter<"EventRSVP"> | string
    created_at?: DateTimeFilter<"EventRSVP"> | Date | string
    event?: XOR<EventRelationFilter, EventWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type EventRSVPOrderByWithRelationInput = {
    event_id?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    event?: EventOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type EventRSVPWhereUniqueInput = Prisma.AtLeast<{
    event_id_user_id?: EventRSVPEvent_idUser_idCompoundUniqueInput
    AND?: EventRSVPWhereInput | EventRSVPWhereInput[]
    OR?: EventRSVPWhereInput[]
    NOT?: EventRSVPWhereInput | EventRSVPWhereInput[]
    event_id?: StringFilter<"EventRSVP"> | string
    user_id?: StringFilter<"EventRSVP"> | string
    created_at?: DateTimeFilter<"EventRSVP"> | Date | string
    event?: XOR<EventRelationFilter, EventWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "event_id_user_id">

  export type EventRSVPOrderByWithAggregationInput = {
    event_id?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
    _count?: EventRSVPCountOrderByAggregateInput
    _max?: EventRSVPMaxOrderByAggregateInput
    _min?: EventRSVPMinOrderByAggregateInput
  }

  export type EventRSVPScalarWhereWithAggregatesInput = {
    AND?: EventRSVPScalarWhereWithAggregatesInput | EventRSVPScalarWhereWithAggregatesInput[]
    OR?: EventRSVPScalarWhereWithAggregatesInput[]
    NOT?: EventRSVPScalarWhereWithAggregatesInput | EventRSVPScalarWhereWithAggregatesInput[]
    event_id?: StringWithAggregatesFilter<"EventRSVP"> | string
    user_id?: StringWithAggregatesFilter<"EventRSVP"> | string
    created_at?: DateTimeWithAggregatesFilter<"EventRSVP"> | Date | string
  }

  export type LivestreamSourceWhereInput = {
    AND?: LivestreamSourceWhereInput | LivestreamSourceWhereInput[]
    OR?: LivestreamSourceWhereInput[]
    NOT?: LivestreamSourceWhereInput | LivestreamSourceWhereInput[]
    id?: StringFilter<"LivestreamSource"> | string
    name?: StringFilter<"LivestreamSource"> | string
    stream_url?: StringFilter<"LivestreamSource"> | string
    camera_location?: StringFilter<"LivestreamSource"> | string
    status?: EnumStreamStatusFilter<"LivestreamSource"> | $Enums.StreamStatus
    thumbnail_url?: StringNullableFilter<"LivestreamSource"> | string | null
    created_at?: DateTimeFilter<"LivestreamSource"> | Date | string
  }

  export type LivestreamSourceOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    stream_url?: SortOrder
    camera_location?: SortOrder
    status?: SortOrder
    thumbnail_url?: SortOrderInput | SortOrder
    created_at?: SortOrder
  }

  export type LivestreamSourceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LivestreamSourceWhereInput | LivestreamSourceWhereInput[]
    OR?: LivestreamSourceWhereInput[]
    NOT?: LivestreamSourceWhereInput | LivestreamSourceWhereInput[]
    name?: StringFilter<"LivestreamSource"> | string
    stream_url?: StringFilter<"LivestreamSource"> | string
    camera_location?: StringFilter<"LivestreamSource"> | string
    status?: EnumStreamStatusFilter<"LivestreamSource"> | $Enums.StreamStatus
    thumbnail_url?: StringNullableFilter<"LivestreamSource"> | string | null
    created_at?: DateTimeFilter<"LivestreamSource"> | Date | string
  }, "id">

  export type LivestreamSourceOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    stream_url?: SortOrder
    camera_location?: SortOrder
    status?: SortOrder
    thumbnail_url?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: LivestreamSourceCountOrderByAggregateInput
    _max?: LivestreamSourceMaxOrderByAggregateInput
    _min?: LivestreamSourceMinOrderByAggregateInput
  }

  export type LivestreamSourceScalarWhereWithAggregatesInput = {
    AND?: LivestreamSourceScalarWhereWithAggregatesInput | LivestreamSourceScalarWhereWithAggregatesInput[]
    OR?: LivestreamSourceScalarWhereWithAggregatesInput[]
    NOT?: LivestreamSourceScalarWhereWithAggregatesInput | LivestreamSourceScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"LivestreamSource"> | string
    name?: StringWithAggregatesFilter<"LivestreamSource"> | string
    stream_url?: StringWithAggregatesFilter<"LivestreamSource"> | string
    camera_location?: StringWithAggregatesFilter<"LivestreamSource"> | string
    status?: EnumStreamStatusWithAggregatesFilter<"LivestreamSource"> | $Enums.StreamStatus
    thumbnail_url?: StringNullableWithAggregatesFilter<"LivestreamSource"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"LivestreamSource"> | Date | string
  }

  export type VolunteerHourWhereInput = {
    AND?: VolunteerHourWhereInput | VolunteerHourWhereInput[]
    OR?: VolunteerHourWhereInput[]
    NOT?: VolunteerHourWhereInput | VolunteerHourWhereInput[]
    id?: StringFilter<"VolunteerHour"> | string
    volunteer_id?: StringFilter<"VolunteerHour"> | string
    date?: DateTimeFilter<"VolunteerHour"> | Date | string
    hours?: FloatFilter<"VolunteerHour"> | number
    task_description?: StringFilter<"VolunteerHour"> | string
    verified_by?: StringNullableFilter<"VolunteerHour"> | string | null
    created_at?: DateTimeFilter<"VolunteerHour"> | Date | string
    volunteer?: XOR<UserRelationFilter, UserWhereInput>
    verifier?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type VolunteerHourOrderByWithRelationInput = {
    id?: SortOrder
    volunteer_id?: SortOrder
    date?: SortOrder
    hours?: SortOrder
    task_description?: SortOrder
    verified_by?: SortOrderInput | SortOrder
    created_at?: SortOrder
    volunteer?: UserOrderByWithRelationInput
    verifier?: UserOrderByWithRelationInput
  }

  export type VolunteerHourWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VolunteerHourWhereInput | VolunteerHourWhereInput[]
    OR?: VolunteerHourWhereInput[]
    NOT?: VolunteerHourWhereInput | VolunteerHourWhereInput[]
    volunteer_id?: StringFilter<"VolunteerHour"> | string
    date?: DateTimeFilter<"VolunteerHour"> | Date | string
    hours?: FloatFilter<"VolunteerHour"> | number
    task_description?: StringFilter<"VolunteerHour"> | string
    verified_by?: StringNullableFilter<"VolunteerHour"> | string | null
    created_at?: DateTimeFilter<"VolunteerHour"> | Date | string
    volunteer?: XOR<UserRelationFilter, UserWhereInput>
    verifier?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type VolunteerHourOrderByWithAggregationInput = {
    id?: SortOrder
    volunteer_id?: SortOrder
    date?: SortOrder
    hours?: SortOrder
    task_description?: SortOrder
    verified_by?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: VolunteerHourCountOrderByAggregateInput
    _avg?: VolunteerHourAvgOrderByAggregateInput
    _max?: VolunteerHourMaxOrderByAggregateInput
    _min?: VolunteerHourMinOrderByAggregateInput
    _sum?: VolunteerHourSumOrderByAggregateInput
  }

  export type VolunteerHourScalarWhereWithAggregatesInput = {
    AND?: VolunteerHourScalarWhereWithAggregatesInput | VolunteerHourScalarWhereWithAggregatesInput[]
    OR?: VolunteerHourScalarWhereWithAggregatesInput[]
    NOT?: VolunteerHourScalarWhereWithAggregatesInput | VolunteerHourScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"VolunteerHour"> | string
    volunteer_id?: StringWithAggregatesFilter<"VolunteerHour"> | string
    date?: DateTimeWithAggregatesFilter<"VolunteerHour"> | Date | string
    hours?: FloatWithAggregatesFilter<"VolunteerHour"> | number
    task_description?: StringWithAggregatesFilter<"VolunteerHour"> | string
    verified_by?: StringNullableWithAggregatesFilter<"VolunteerHour"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"VolunteerHour"> | Date | string
  }

  export type EquipmentItemWhereInput = {
    AND?: EquipmentItemWhereInput | EquipmentItemWhereInput[]
    OR?: EquipmentItemWhereInput[]
    NOT?: EquipmentItemWhereInput | EquipmentItemWhereInput[]
    id?: StringFilter<"EquipmentItem"> | string
    name?: StringFilter<"EquipmentItem"> | string
    description?: StringNullableFilter<"EquipmentItem"> | string | null
    status?: EnumEquipmentStatusFilter<"EquipmentItem"> | $Enums.EquipmentStatus
    checked_out_by?: StringNullableFilter<"EquipmentItem"> | string | null
    checked_out_at?: DateTimeNullableFilter<"EquipmentItem"> | Date | string | null
    created_at?: DateTimeFilter<"EquipmentItem"> | Date | string
    checker?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }

  export type EquipmentItemOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    status?: SortOrder
    checked_out_by?: SortOrderInput | SortOrder
    checked_out_at?: SortOrderInput | SortOrder
    created_at?: SortOrder
    checker?: UserOrderByWithRelationInput
  }

  export type EquipmentItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EquipmentItemWhereInput | EquipmentItemWhereInput[]
    OR?: EquipmentItemWhereInput[]
    NOT?: EquipmentItemWhereInput | EquipmentItemWhereInput[]
    name?: StringFilter<"EquipmentItem"> | string
    description?: StringNullableFilter<"EquipmentItem"> | string | null
    status?: EnumEquipmentStatusFilter<"EquipmentItem"> | $Enums.EquipmentStatus
    checked_out_by?: StringNullableFilter<"EquipmentItem"> | string | null
    checked_out_at?: DateTimeNullableFilter<"EquipmentItem"> | Date | string | null
    created_at?: DateTimeFilter<"EquipmentItem"> | Date | string
    checker?: XOR<UserNullableRelationFilter, UserWhereInput> | null
  }, "id">

  export type EquipmentItemOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    status?: SortOrder
    checked_out_by?: SortOrderInput | SortOrder
    checked_out_at?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: EquipmentItemCountOrderByAggregateInput
    _max?: EquipmentItemMaxOrderByAggregateInput
    _min?: EquipmentItemMinOrderByAggregateInput
  }

  export type EquipmentItemScalarWhereWithAggregatesInput = {
    AND?: EquipmentItemScalarWhereWithAggregatesInput | EquipmentItemScalarWhereWithAggregatesInput[]
    OR?: EquipmentItemScalarWhereWithAggregatesInput[]
    NOT?: EquipmentItemScalarWhereWithAggregatesInput | EquipmentItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"EquipmentItem"> | string
    name?: StringWithAggregatesFilter<"EquipmentItem"> | string
    description?: StringNullableWithAggregatesFilter<"EquipmentItem"> | string | null
    status?: EnumEquipmentStatusWithAggregatesFilter<"EquipmentItem"> | $Enums.EquipmentStatus
    checked_out_by?: StringNullableWithAggregatesFilter<"EquipmentItem"> | string | null
    checked_out_at?: DateTimeNullableWithAggregatesFilter<"EquipmentItem"> | Date | string | null
    created_at?: DateTimeWithAggregatesFilter<"EquipmentItem"> | Date | string
  }

  export type UserCreateInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BurrowCreateInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    created_at?: Date | string
    assigned_volunteer?: UserCreateNestedOneWithoutBurrowsInput
  }

  export type BurrowUncheckedCreateInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    assigned_volunteer_id?: string | null
    created_at?: Date | string
  }

  export type BurrowUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    assigned_volunteer?: UserUpdateOneWithoutBurrowsNestedInput
  }

  export type BurrowUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    assigned_volunteer_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BurrowCreateManyInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    assigned_volunteer_id?: string | null
    created_at?: Date | string
  }

  export type BurrowUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BurrowUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    assigned_volunteer_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationCreateInput = {
    id?: string
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
    donor?: UserCreateNestedOneWithoutDonationsInput
  }

  export type DonationUncheckedCreateInput = {
    id?: string
    donor_id?: string | null
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
  }

  export type DonationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    donor?: UserUpdateOneWithoutDonationsNestedInput
  }

  export type DonationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    donor_id?: NullableStringFieldUpdateOperationsInput | string | null
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationCreateManyInput = {
    id?: string
    donor_id?: string | null
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
  }

  export type DonationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    donor_id?: NullableStringFieldUpdateOperationsInput | string | null
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingCreateInput = {
    id?: string
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
    reporter?: UserCreateNestedOneWithoutSightingsInput
  }

  export type WildlifeSightingUncheckedCreateInput = {
    id?: string
    reporter_id?: string | null
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
  }

  export type WildlifeSightingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    reporter?: UserUpdateOneWithoutSightingsNestedInput
  }

  export type WildlifeSightingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    reporter_id?: NullableStringFieldUpdateOperationsInput | string | null
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingCreateManyInput = {
    id?: string
    reporter_id?: string | null
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
  }

  export type WildlifeSightingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    reporter_id?: NullableStringFieldUpdateOperationsInput | string | null
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCreateInput = {
    id?: string
    title: string
    description?: string | null
    date: Date | string
    location: string
    max_attendees?: number | null
    type: $Enums.EventType
    created_at?: Date | string
    rsvps?: EventRSVPCreateNestedManyWithoutEventInput
  }

  export type EventUncheckedCreateInput = {
    id?: string
    title: string
    description?: string | null
    date: Date | string
    location: string
    max_attendees?: number | null
    type: $Enums.EventType
    created_at?: Date | string
    rsvps?: EventRSVPUncheckedCreateNestedManyWithoutEventInput
  }

  export type EventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    rsvps?: EventRSVPUpdateManyWithoutEventNestedInput
  }

  export type EventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    rsvps?: EventRSVPUncheckedUpdateManyWithoutEventNestedInput
  }

  export type EventCreateManyInput = {
    id?: string
    title: string
    description?: string | null
    date: Date | string
    location: string
    max_attendees?: number | null
    type: $Enums.EventType
    created_at?: Date | string
  }

  export type EventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPCreateInput = {
    created_at?: Date | string
    event: EventCreateNestedOneWithoutRsvpsInput
    user: UserCreateNestedOneWithoutEvent_rsvpsInput
  }

  export type EventRSVPUncheckedCreateInput = {
    event_id: string
    user_id: string
    created_at?: Date | string
  }

  export type EventRSVPUpdateInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    event?: EventUpdateOneRequiredWithoutRsvpsNestedInput
    user?: UserUpdateOneRequiredWithoutEvent_rsvpsNestedInput
  }

  export type EventRSVPUncheckedUpdateInput = {
    event_id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPCreateManyInput = {
    event_id: string
    user_id: string
    created_at?: Date | string
  }

  export type EventRSVPUpdateManyMutationInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPUncheckedUpdateManyInput = {
    event_id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LivestreamSourceCreateInput = {
    id?: string
    name: string
    stream_url: string
    camera_location: string
    status?: $Enums.StreamStatus
    thumbnail_url?: string | null
    created_at?: Date | string
  }

  export type LivestreamSourceUncheckedCreateInput = {
    id?: string
    name: string
    stream_url: string
    camera_location: string
    status?: $Enums.StreamStatus
    thumbnail_url?: string | null
    created_at?: Date | string
  }

  export type LivestreamSourceUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    stream_url?: StringFieldUpdateOperationsInput | string
    camera_location?: StringFieldUpdateOperationsInput | string
    status?: EnumStreamStatusFieldUpdateOperationsInput | $Enums.StreamStatus
    thumbnail_url?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LivestreamSourceUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    stream_url?: StringFieldUpdateOperationsInput | string
    camera_location?: StringFieldUpdateOperationsInput | string
    status?: EnumStreamStatusFieldUpdateOperationsInput | $Enums.StreamStatus
    thumbnail_url?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LivestreamSourceCreateManyInput = {
    id?: string
    name: string
    stream_url: string
    camera_location: string
    status?: $Enums.StreamStatus
    thumbnail_url?: string | null
    created_at?: Date | string
  }

  export type LivestreamSourceUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    stream_url?: StringFieldUpdateOperationsInput | string
    camera_location?: StringFieldUpdateOperationsInput | string
    status?: EnumStreamStatusFieldUpdateOperationsInput | $Enums.StreamStatus
    thumbnail_url?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LivestreamSourceUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    stream_url?: StringFieldUpdateOperationsInput | string
    camera_location?: StringFieldUpdateOperationsInput | string
    status?: EnumStreamStatusFieldUpdateOperationsInput | $Enums.StreamStatus
    thumbnail_url?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourCreateInput = {
    id?: string
    date: Date | string
    hours: number
    task_description: string
    created_at?: Date | string
    volunteer: UserCreateNestedOneWithoutVolunteer_hoursInput
    verifier?: UserCreateNestedOneWithoutVerified_hoursInput
  }

  export type VolunteerHourUncheckedCreateInput = {
    id?: string
    volunteer_id: string
    date: Date | string
    hours: number
    task_description: string
    verified_by?: string | null
    created_at?: Date | string
  }

  export type VolunteerHourUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    volunteer?: UserUpdateOneRequiredWithoutVolunteer_hoursNestedInput
    verifier?: UserUpdateOneWithoutVerified_hoursNestedInput
  }

  export type VolunteerHourUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    volunteer_id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    verified_by?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourCreateManyInput = {
    id?: string
    volunteer_id: string
    date: Date | string
    hours: number
    task_description: string
    verified_by?: string | null
    created_at?: Date | string
  }

  export type VolunteerHourUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    volunteer_id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    verified_by?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemCreateInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_at?: Date | string | null
    created_at?: Date | string
    checker?: UserCreateNestedOneWithoutEquipment_itemsInput
  }

  export type EquipmentItemUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_by?: string | null
    checked_out_at?: Date | string | null
    created_at?: Date | string
  }

  export type EquipmentItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    checker?: UserUpdateOneWithoutEquipment_itemsNestedInput
  }

  export type EquipmentItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_by?: NullableStringFieldUpdateOperationsInput | string | null
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_by?: string | null
    checked_out_at?: Date | string | null
    created_at?: Date | string
  }

  export type EquipmentItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_by?: NullableStringFieldUpdateOperationsInput | string | null
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type EnumUserRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type BurrowListRelationFilter = {
    every?: BurrowWhereInput
    some?: BurrowWhereInput
    none?: BurrowWhereInput
  }

  export type DonationListRelationFilter = {
    every?: DonationWhereInput
    some?: DonationWhereInput
    none?: DonationWhereInput
  }

  export type WildlifeSightingListRelationFilter = {
    every?: WildlifeSightingWhereInput
    some?: WildlifeSightingWhereInput
    none?: WildlifeSightingWhereInput
  }

  export type EventRSVPListRelationFilter = {
    every?: EventRSVPWhereInput
    some?: EventRSVPWhereInput
    none?: EventRSVPWhereInput
  }

  export type VolunteerHourListRelationFilter = {
    every?: VolunteerHourWhereInput
    some?: VolunteerHourWhereInput
    none?: VolunteerHourWhereInput
  }

  export type EquipmentItemListRelationFilter = {
    every?: EquipmentItemWhereInput
    some?: EquipmentItemWhereInput
    none?: EquipmentItemWhereInput
  }

  export type BurrowOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type DonationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type WildlifeSightingOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type EventRSVPOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type VolunteerHourOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type EquipmentItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    role?: SortOrder
    password_hash?: SortOrder
    created_at?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    role?: SortOrder
    password_hash?: SortOrder
    created_at?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    role?: SortOrder
    password_hash?: SortOrder
    created_at?: 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 EnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumUserRoleFilter<$PrismaModel>
    _max?: NestedEnumUserRoleFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type 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 EnumBurrowStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.BurrowStatus | EnumBurrowStatusFieldRefInput<$PrismaModel>
    in?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumBurrowStatusFilter<$PrismaModel> | $Enums.BurrowStatus
  }

  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 StringNullableListFilter<$PrismaModel = never> = {
    equals?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    has?: string | StringFieldRefInput<$PrismaModel> | null
    hasEvery?: string[] | ListStringFieldRefInput<$PrismaModel>
    hasSome?: string[] | ListStringFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }

  export type UserNullableRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type BurrowCountOrderByAggregateInput = {
    id?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    status?: SortOrder
    location_description?: SortOrder
    photos?: SortOrder
    assigned_volunteer_id?: SortOrder
    created_at?: SortOrder
  }

  export type BurrowAvgOrderByAggregateInput = {
    gps_lat?: SortOrder
    gps_lng?: SortOrder
  }

  export type BurrowMaxOrderByAggregateInput = {
    id?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    status?: SortOrder
    location_description?: SortOrder
    assigned_volunteer_id?: SortOrder
    created_at?: SortOrder
  }

  export type BurrowMinOrderByAggregateInput = {
    id?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    status?: SortOrder
    location_description?: SortOrder
    assigned_volunteer_id?: SortOrder
    created_at?: SortOrder
  }

  export type BurrowSumOrderByAggregateInput = {
    gps_lat?: SortOrder
    gps_lng?: SortOrder
  }

  export type FloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type EnumBurrowStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.BurrowStatus | EnumBurrowStatusFieldRefInput<$PrismaModel>
    in?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumBurrowStatusWithAggregatesFilter<$PrismaModel> | $Enums.BurrowStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumBurrowStatusFilter<$PrismaModel>
    _max?: NestedEnumBurrowStatusFilter<$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 EnumDonationCampaignFilter<$PrismaModel = never> = {
    equals?: $Enums.DonationCampaign | EnumDonationCampaignFieldRefInput<$PrismaModel>
    in?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    notIn?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    not?: NestedEnumDonationCampaignFilter<$PrismaModel> | $Enums.DonationCampaign
  }

  export type DonationCountOrderByAggregateInput = {
    id?: SortOrder
    donor_id?: SortOrder
    amount?: SortOrder
    campaign?: SortOrder
    stripe_payment_id?: SortOrder
    created_at?: SortOrder
  }

  export type DonationAvgOrderByAggregateInput = {
    amount?: SortOrder
  }

  export type DonationMaxOrderByAggregateInput = {
    id?: SortOrder
    donor_id?: SortOrder
    amount?: SortOrder
    campaign?: SortOrder
    stripe_payment_id?: SortOrder
    created_at?: SortOrder
  }

  export type DonationMinOrderByAggregateInput = {
    id?: SortOrder
    donor_id?: SortOrder
    amount?: SortOrder
    campaign?: SortOrder
    stripe_payment_id?: SortOrder
    created_at?: SortOrder
  }

  export type DonationSumOrderByAggregateInput = {
    amount?: SortOrder
  }

  export type EnumDonationCampaignWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.DonationCampaign | EnumDonationCampaignFieldRefInput<$PrismaModel>
    in?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    notIn?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    not?: NestedEnumDonationCampaignWithAggregatesFilter<$PrismaModel> | $Enums.DonationCampaign
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumDonationCampaignFilter<$PrismaModel>
    _max?: NestedEnumDonationCampaignFilter<$PrismaModel>
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type WildlifeSightingCountOrderByAggregateInput = {
    id?: SortOrder
    reporter_id?: SortOrder
    species?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    photo_url?: SortOrder
    description?: SortOrder
    verified?: SortOrder
    created_at?: SortOrder
  }

  export type WildlifeSightingAvgOrderByAggregateInput = {
    gps_lat?: SortOrder
    gps_lng?: SortOrder
  }

  export type WildlifeSightingMaxOrderByAggregateInput = {
    id?: SortOrder
    reporter_id?: SortOrder
    species?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    photo_url?: SortOrder
    description?: SortOrder
    verified?: SortOrder
    created_at?: SortOrder
  }

  export type WildlifeSightingMinOrderByAggregateInput = {
    id?: SortOrder
    reporter_id?: SortOrder
    species?: SortOrder
    gps_lat?: SortOrder
    gps_lng?: SortOrder
    photo_url?: SortOrder
    description?: SortOrder
    verified?: SortOrder
    created_at?: SortOrder
  }

  export type WildlifeSightingSumOrderByAggregateInput = {
    gps_lat?: SortOrder
    gps_lng?: SortOrder
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type 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 EnumEventTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeFilter<$PrismaModel> | $Enums.EventType
  }

  export type EventCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    date?: SortOrder
    location?: SortOrder
    max_attendees?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
  }

  export type EventAvgOrderByAggregateInput = {
    max_attendees?: SortOrder
  }

  export type EventMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    date?: SortOrder
    location?: SortOrder
    max_attendees?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
  }

  export type EventMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    date?: SortOrder
    location?: SortOrder
    max_attendees?: SortOrder
    type?: SortOrder
    created_at?: SortOrder
  }

  export type EventSumOrderByAggregateInput = {
    max_attendees?: SortOrder
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type EnumEventTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeWithAggregatesFilter<$PrismaModel> | $Enums.EventType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEventTypeFilter<$PrismaModel>
    _max?: NestedEnumEventTypeFilter<$PrismaModel>
  }

  export type EventRelationFilter = {
    is?: EventWhereInput
    isNot?: EventWhereInput
  }

  export type UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type EventRSVPEvent_idUser_idCompoundUniqueInput = {
    event_id: string
    user_id: string
  }

  export type EventRSVPCountOrderByAggregateInput = {
    event_id?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
  }

  export type EventRSVPMaxOrderByAggregateInput = {
    event_id?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
  }

  export type EventRSVPMinOrderByAggregateInput = {
    event_id?: SortOrder
    user_id?: SortOrder
    created_at?: SortOrder
  }

  export type EnumStreamStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.StreamStatus | EnumStreamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStreamStatusFilter<$PrismaModel> | $Enums.StreamStatus
  }

  export type LivestreamSourceCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    stream_url?: SortOrder
    camera_location?: SortOrder
    status?: SortOrder
    thumbnail_url?: SortOrder
    created_at?: SortOrder
  }

  export type LivestreamSourceMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    stream_url?: SortOrder
    camera_location?: SortOrder
    status?: SortOrder
    thumbnail_url?: SortOrder
    created_at?: SortOrder
  }

  export type LivestreamSourceMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    stream_url?: SortOrder
    camera_location?: SortOrder
    status?: SortOrder
    thumbnail_url?: SortOrder
    created_at?: SortOrder
  }

  export type EnumStreamStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StreamStatus | EnumStreamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStreamStatusWithAggregatesFilter<$PrismaModel> | $Enums.StreamStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStreamStatusFilter<$PrismaModel>
    _max?: NestedEnumStreamStatusFilter<$PrismaModel>
  }

  export type VolunteerHourCountOrderByAggregateInput = {
    id?: SortOrder
    volunteer_id?: SortOrder
    date?: SortOrder
    hours?: SortOrder
    task_description?: SortOrder
    verified_by?: SortOrder
    created_at?: SortOrder
  }

  export type VolunteerHourAvgOrderByAggregateInput = {
    hours?: SortOrder
  }

  export type VolunteerHourMaxOrderByAggregateInput = {
    id?: SortOrder
    volunteer_id?: SortOrder
    date?: SortOrder
    hours?: SortOrder
    task_description?: SortOrder
    verified_by?: SortOrder
    created_at?: SortOrder
  }

  export type VolunteerHourMinOrderByAggregateInput = {
    id?: SortOrder
    volunteer_id?: SortOrder
    date?: SortOrder
    hours?: SortOrder
    task_description?: SortOrder
    verified_by?: SortOrder
    created_at?: SortOrder
  }

  export type VolunteerHourSumOrderByAggregateInput = {
    hours?: SortOrder
  }

  export type EnumEquipmentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.EquipmentStatus | EnumEquipmentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumEquipmentStatusFilter<$PrismaModel> | $Enums.EquipmentStatus
  }

  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 EquipmentItemCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    status?: SortOrder
    checked_out_by?: SortOrder
    checked_out_at?: SortOrder
    created_at?: SortOrder
  }

  export type EquipmentItemMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    status?: SortOrder
    checked_out_by?: SortOrder
    checked_out_at?: SortOrder
    created_at?: SortOrder
  }

  export type EquipmentItemMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    status?: SortOrder
    checked_out_by?: SortOrder
    checked_out_at?: SortOrder
    created_at?: SortOrder
  }

  export type EnumEquipmentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EquipmentStatus | EnumEquipmentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumEquipmentStatusWithAggregatesFilter<$PrismaModel> | $Enums.EquipmentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEquipmentStatusFilter<$PrismaModel>
    _max?: NestedEnumEquipmentStatusFilter<$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 BurrowCreateNestedManyWithoutAssigned_volunteerInput = {
    create?: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput> | BurrowCreateWithoutAssigned_volunteerInput[] | BurrowUncheckedCreateWithoutAssigned_volunteerInput[]
    connectOrCreate?: BurrowCreateOrConnectWithoutAssigned_volunteerInput | BurrowCreateOrConnectWithoutAssigned_volunteerInput[]
    createMany?: BurrowCreateManyAssigned_volunteerInputEnvelope
    connect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
  }

  export type DonationCreateNestedManyWithoutDonorInput = {
    create?: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput> | DonationCreateWithoutDonorInput[] | DonationUncheckedCreateWithoutDonorInput[]
    connectOrCreate?: DonationCreateOrConnectWithoutDonorInput | DonationCreateOrConnectWithoutDonorInput[]
    createMany?: DonationCreateManyDonorInputEnvelope
    connect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
  }

  export type WildlifeSightingCreateNestedManyWithoutReporterInput = {
    create?: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput> | WildlifeSightingCreateWithoutReporterInput[] | WildlifeSightingUncheckedCreateWithoutReporterInput[]
    connectOrCreate?: WildlifeSightingCreateOrConnectWithoutReporterInput | WildlifeSightingCreateOrConnectWithoutReporterInput[]
    createMany?: WildlifeSightingCreateManyReporterInputEnvelope
    connect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
  }

  export type EventRSVPCreateNestedManyWithoutUserInput = {
    create?: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput> | EventRSVPCreateWithoutUserInput[] | EventRSVPUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutUserInput | EventRSVPCreateOrConnectWithoutUserInput[]
    createMany?: EventRSVPCreateManyUserInputEnvelope
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
  }

  export type VolunteerHourCreateNestedManyWithoutVolunteerInput = {
    create?: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput> | VolunteerHourCreateWithoutVolunteerInput[] | VolunteerHourUncheckedCreateWithoutVolunteerInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVolunteerInput | VolunteerHourCreateOrConnectWithoutVolunteerInput[]
    createMany?: VolunteerHourCreateManyVolunteerInputEnvelope
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
  }

  export type EquipmentItemCreateNestedManyWithoutCheckerInput = {
    create?: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput> | EquipmentItemCreateWithoutCheckerInput[] | EquipmentItemUncheckedCreateWithoutCheckerInput[]
    connectOrCreate?: EquipmentItemCreateOrConnectWithoutCheckerInput | EquipmentItemCreateOrConnectWithoutCheckerInput[]
    createMany?: EquipmentItemCreateManyCheckerInputEnvelope
    connect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
  }

  export type VolunteerHourCreateNestedManyWithoutVerifierInput = {
    create?: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput> | VolunteerHourCreateWithoutVerifierInput[] | VolunteerHourUncheckedCreateWithoutVerifierInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVerifierInput | VolunteerHourCreateOrConnectWithoutVerifierInput[]
    createMany?: VolunteerHourCreateManyVerifierInputEnvelope
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
  }

  export type BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput = {
    create?: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput> | BurrowCreateWithoutAssigned_volunteerInput[] | BurrowUncheckedCreateWithoutAssigned_volunteerInput[]
    connectOrCreate?: BurrowCreateOrConnectWithoutAssigned_volunteerInput | BurrowCreateOrConnectWithoutAssigned_volunteerInput[]
    createMany?: BurrowCreateManyAssigned_volunteerInputEnvelope
    connect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
  }

  export type DonationUncheckedCreateNestedManyWithoutDonorInput = {
    create?: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput> | DonationCreateWithoutDonorInput[] | DonationUncheckedCreateWithoutDonorInput[]
    connectOrCreate?: DonationCreateOrConnectWithoutDonorInput | DonationCreateOrConnectWithoutDonorInput[]
    createMany?: DonationCreateManyDonorInputEnvelope
    connect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
  }

  export type WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput = {
    create?: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput> | WildlifeSightingCreateWithoutReporterInput[] | WildlifeSightingUncheckedCreateWithoutReporterInput[]
    connectOrCreate?: WildlifeSightingCreateOrConnectWithoutReporterInput | WildlifeSightingCreateOrConnectWithoutReporterInput[]
    createMany?: WildlifeSightingCreateManyReporterInputEnvelope
    connect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
  }

  export type EventRSVPUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput> | EventRSVPCreateWithoutUserInput[] | EventRSVPUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutUserInput | EventRSVPCreateOrConnectWithoutUserInput[]
    createMany?: EventRSVPCreateManyUserInputEnvelope
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
  }

  export type VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput = {
    create?: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput> | VolunteerHourCreateWithoutVolunteerInput[] | VolunteerHourUncheckedCreateWithoutVolunteerInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVolunteerInput | VolunteerHourCreateOrConnectWithoutVolunteerInput[]
    createMany?: VolunteerHourCreateManyVolunteerInputEnvelope
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
  }

  export type EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput = {
    create?: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput> | EquipmentItemCreateWithoutCheckerInput[] | EquipmentItemUncheckedCreateWithoutCheckerInput[]
    connectOrCreate?: EquipmentItemCreateOrConnectWithoutCheckerInput | EquipmentItemCreateOrConnectWithoutCheckerInput[]
    createMany?: EquipmentItemCreateManyCheckerInputEnvelope
    connect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
  }

  export type VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput = {
    create?: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput> | VolunteerHourCreateWithoutVerifierInput[] | VolunteerHourUncheckedCreateWithoutVerifierInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVerifierInput | VolunteerHourCreateOrConnectWithoutVerifierInput[]
    createMany?: VolunteerHourCreateManyVerifierInputEnvelope
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type EnumUserRoleFieldUpdateOperationsInput = {
    set?: $Enums.UserRole
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type BurrowUpdateManyWithoutAssigned_volunteerNestedInput = {
    create?: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput> | BurrowCreateWithoutAssigned_volunteerInput[] | BurrowUncheckedCreateWithoutAssigned_volunteerInput[]
    connectOrCreate?: BurrowCreateOrConnectWithoutAssigned_volunteerInput | BurrowCreateOrConnectWithoutAssigned_volunteerInput[]
    upsert?: BurrowUpsertWithWhereUniqueWithoutAssigned_volunteerInput | BurrowUpsertWithWhereUniqueWithoutAssigned_volunteerInput[]
    createMany?: BurrowCreateManyAssigned_volunteerInputEnvelope
    set?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    disconnect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    delete?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    connect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    update?: BurrowUpdateWithWhereUniqueWithoutAssigned_volunteerInput | BurrowUpdateWithWhereUniqueWithoutAssigned_volunteerInput[]
    updateMany?: BurrowUpdateManyWithWhereWithoutAssigned_volunteerInput | BurrowUpdateManyWithWhereWithoutAssigned_volunteerInput[]
    deleteMany?: BurrowScalarWhereInput | BurrowScalarWhereInput[]
  }

  export type DonationUpdateManyWithoutDonorNestedInput = {
    create?: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput> | DonationCreateWithoutDonorInput[] | DonationUncheckedCreateWithoutDonorInput[]
    connectOrCreate?: DonationCreateOrConnectWithoutDonorInput | DonationCreateOrConnectWithoutDonorInput[]
    upsert?: DonationUpsertWithWhereUniqueWithoutDonorInput | DonationUpsertWithWhereUniqueWithoutDonorInput[]
    createMany?: DonationCreateManyDonorInputEnvelope
    set?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    disconnect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    delete?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    connect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    update?: DonationUpdateWithWhereUniqueWithoutDonorInput | DonationUpdateWithWhereUniqueWithoutDonorInput[]
    updateMany?: DonationUpdateManyWithWhereWithoutDonorInput | DonationUpdateManyWithWhereWithoutDonorInput[]
    deleteMany?: DonationScalarWhereInput | DonationScalarWhereInput[]
  }

  export type WildlifeSightingUpdateManyWithoutReporterNestedInput = {
    create?: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput> | WildlifeSightingCreateWithoutReporterInput[] | WildlifeSightingUncheckedCreateWithoutReporterInput[]
    connectOrCreate?: WildlifeSightingCreateOrConnectWithoutReporterInput | WildlifeSightingCreateOrConnectWithoutReporterInput[]
    upsert?: WildlifeSightingUpsertWithWhereUniqueWithoutReporterInput | WildlifeSightingUpsertWithWhereUniqueWithoutReporterInput[]
    createMany?: WildlifeSightingCreateManyReporterInputEnvelope
    set?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    disconnect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    delete?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    connect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    update?: WildlifeSightingUpdateWithWhereUniqueWithoutReporterInput | WildlifeSightingUpdateWithWhereUniqueWithoutReporterInput[]
    updateMany?: WildlifeSightingUpdateManyWithWhereWithoutReporterInput | WildlifeSightingUpdateManyWithWhereWithoutReporterInput[]
    deleteMany?: WildlifeSightingScalarWhereInput | WildlifeSightingScalarWhereInput[]
  }

  export type EventRSVPUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput> | EventRSVPCreateWithoutUserInput[] | EventRSVPUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutUserInput | EventRSVPCreateOrConnectWithoutUserInput[]
    upsert?: EventRSVPUpsertWithWhereUniqueWithoutUserInput | EventRSVPUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventRSVPCreateManyUserInputEnvelope
    set?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    disconnect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    delete?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    update?: EventRSVPUpdateWithWhereUniqueWithoutUserInput | EventRSVPUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventRSVPUpdateManyWithWhereWithoutUserInput | EventRSVPUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
  }

  export type VolunteerHourUpdateManyWithoutVolunteerNestedInput = {
    create?: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput> | VolunteerHourCreateWithoutVolunteerInput[] | VolunteerHourUncheckedCreateWithoutVolunteerInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVolunteerInput | VolunteerHourCreateOrConnectWithoutVolunteerInput[]
    upsert?: VolunteerHourUpsertWithWhereUniqueWithoutVolunteerInput | VolunteerHourUpsertWithWhereUniqueWithoutVolunteerInput[]
    createMany?: VolunteerHourCreateManyVolunteerInputEnvelope
    set?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    disconnect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    delete?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    update?: VolunteerHourUpdateWithWhereUniqueWithoutVolunteerInput | VolunteerHourUpdateWithWhereUniqueWithoutVolunteerInput[]
    updateMany?: VolunteerHourUpdateManyWithWhereWithoutVolunteerInput | VolunteerHourUpdateManyWithWhereWithoutVolunteerInput[]
    deleteMany?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
  }

  export type EquipmentItemUpdateManyWithoutCheckerNestedInput = {
    create?: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput> | EquipmentItemCreateWithoutCheckerInput[] | EquipmentItemUncheckedCreateWithoutCheckerInput[]
    connectOrCreate?: EquipmentItemCreateOrConnectWithoutCheckerInput | EquipmentItemCreateOrConnectWithoutCheckerInput[]
    upsert?: EquipmentItemUpsertWithWhereUniqueWithoutCheckerInput | EquipmentItemUpsertWithWhereUniqueWithoutCheckerInput[]
    createMany?: EquipmentItemCreateManyCheckerInputEnvelope
    set?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    disconnect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    delete?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    connect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    update?: EquipmentItemUpdateWithWhereUniqueWithoutCheckerInput | EquipmentItemUpdateWithWhereUniqueWithoutCheckerInput[]
    updateMany?: EquipmentItemUpdateManyWithWhereWithoutCheckerInput | EquipmentItemUpdateManyWithWhereWithoutCheckerInput[]
    deleteMany?: EquipmentItemScalarWhereInput | EquipmentItemScalarWhereInput[]
  }

  export type VolunteerHourUpdateManyWithoutVerifierNestedInput = {
    create?: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput> | VolunteerHourCreateWithoutVerifierInput[] | VolunteerHourUncheckedCreateWithoutVerifierInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVerifierInput | VolunteerHourCreateOrConnectWithoutVerifierInput[]
    upsert?: VolunteerHourUpsertWithWhereUniqueWithoutVerifierInput | VolunteerHourUpsertWithWhereUniqueWithoutVerifierInput[]
    createMany?: VolunteerHourCreateManyVerifierInputEnvelope
    set?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    disconnect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    delete?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    update?: VolunteerHourUpdateWithWhereUniqueWithoutVerifierInput | VolunteerHourUpdateWithWhereUniqueWithoutVerifierInput[]
    updateMany?: VolunteerHourUpdateManyWithWhereWithoutVerifierInput | VolunteerHourUpdateManyWithWhereWithoutVerifierInput[]
    deleteMany?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
  }

  export type BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput = {
    create?: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput> | BurrowCreateWithoutAssigned_volunteerInput[] | BurrowUncheckedCreateWithoutAssigned_volunteerInput[]
    connectOrCreate?: BurrowCreateOrConnectWithoutAssigned_volunteerInput | BurrowCreateOrConnectWithoutAssigned_volunteerInput[]
    upsert?: BurrowUpsertWithWhereUniqueWithoutAssigned_volunteerInput | BurrowUpsertWithWhereUniqueWithoutAssigned_volunteerInput[]
    createMany?: BurrowCreateManyAssigned_volunteerInputEnvelope
    set?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    disconnect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    delete?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    connect?: BurrowWhereUniqueInput | BurrowWhereUniqueInput[]
    update?: BurrowUpdateWithWhereUniqueWithoutAssigned_volunteerInput | BurrowUpdateWithWhereUniqueWithoutAssigned_volunteerInput[]
    updateMany?: BurrowUpdateManyWithWhereWithoutAssigned_volunteerInput | BurrowUpdateManyWithWhereWithoutAssigned_volunteerInput[]
    deleteMany?: BurrowScalarWhereInput | BurrowScalarWhereInput[]
  }

  export type DonationUncheckedUpdateManyWithoutDonorNestedInput = {
    create?: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput> | DonationCreateWithoutDonorInput[] | DonationUncheckedCreateWithoutDonorInput[]
    connectOrCreate?: DonationCreateOrConnectWithoutDonorInput | DonationCreateOrConnectWithoutDonorInput[]
    upsert?: DonationUpsertWithWhereUniqueWithoutDonorInput | DonationUpsertWithWhereUniqueWithoutDonorInput[]
    createMany?: DonationCreateManyDonorInputEnvelope
    set?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    disconnect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    delete?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    connect?: DonationWhereUniqueInput | DonationWhereUniqueInput[]
    update?: DonationUpdateWithWhereUniqueWithoutDonorInput | DonationUpdateWithWhereUniqueWithoutDonorInput[]
    updateMany?: DonationUpdateManyWithWhereWithoutDonorInput | DonationUpdateManyWithWhereWithoutDonorInput[]
    deleteMany?: DonationScalarWhereInput | DonationScalarWhereInput[]
  }

  export type WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput = {
    create?: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput> | WildlifeSightingCreateWithoutReporterInput[] | WildlifeSightingUncheckedCreateWithoutReporterInput[]
    connectOrCreate?: WildlifeSightingCreateOrConnectWithoutReporterInput | WildlifeSightingCreateOrConnectWithoutReporterInput[]
    upsert?: WildlifeSightingUpsertWithWhereUniqueWithoutReporterInput | WildlifeSightingUpsertWithWhereUniqueWithoutReporterInput[]
    createMany?: WildlifeSightingCreateManyReporterInputEnvelope
    set?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    disconnect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    delete?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    connect?: WildlifeSightingWhereUniqueInput | WildlifeSightingWhereUniqueInput[]
    update?: WildlifeSightingUpdateWithWhereUniqueWithoutReporterInput | WildlifeSightingUpdateWithWhereUniqueWithoutReporterInput[]
    updateMany?: WildlifeSightingUpdateManyWithWhereWithoutReporterInput | WildlifeSightingUpdateManyWithWhereWithoutReporterInput[]
    deleteMany?: WildlifeSightingScalarWhereInput | WildlifeSightingScalarWhereInput[]
  }

  export type EventRSVPUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput> | EventRSVPCreateWithoutUserInput[] | EventRSVPUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutUserInput | EventRSVPCreateOrConnectWithoutUserInput[]
    upsert?: EventRSVPUpsertWithWhereUniqueWithoutUserInput | EventRSVPUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventRSVPCreateManyUserInputEnvelope
    set?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    disconnect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    delete?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    update?: EventRSVPUpdateWithWhereUniqueWithoutUserInput | EventRSVPUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventRSVPUpdateManyWithWhereWithoutUserInput | EventRSVPUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
  }

  export type VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput = {
    create?: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput> | VolunteerHourCreateWithoutVolunteerInput[] | VolunteerHourUncheckedCreateWithoutVolunteerInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVolunteerInput | VolunteerHourCreateOrConnectWithoutVolunteerInput[]
    upsert?: VolunteerHourUpsertWithWhereUniqueWithoutVolunteerInput | VolunteerHourUpsertWithWhereUniqueWithoutVolunteerInput[]
    createMany?: VolunteerHourCreateManyVolunteerInputEnvelope
    set?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    disconnect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    delete?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    update?: VolunteerHourUpdateWithWhereUniqueWithoutVolunteerInput | VolunteerHourUpdateWithWhereUniqueWithoutVolunteerInput[]
    updateMany?: VolunteerHourUpdateManyWithWhereWithoutVolunteerInput | VolunteerHourUpdateManyWithWhereWithoutVolunteerInput[]
    deleteMany?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
  }

  export type EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput = {
    create?: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput> | EquipmentItemCreateWithoutCheckerInput[] | EquipmentItemUncheckedCreateWithoutCheckerInput[]
    connectOrCreate?: EquipmentItemCreateOrConnectWithoutCheckerInput | EquipmentItemCreateOrConnectWithoutCheckerInput[]
    upsert?: EquipmentItemUpsertWithWhereUniqueWithoutCheckerInput | EquipmentItemUpsertWithWhereUniqueWithoutCheckerInput[]
    createMany?: EquipmentItemCreateManyCheckerInputEnvelope
    set?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    disconnect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    delete?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    connect?: EquipmentItemWhereUniqueInput | EquipmentItemWhereUniqueInput[]
    update?: EquipmentItemUpdateWithWhereUniqueWithoutCheckerInput | EquipmentItemUpdateWithWhereUniqueWithoutCheckerInput[]
    updateMany?: EquipmentItemUpdateManyWithWhereWithoutCheckerInput | EquipmentItemUpdateManyWithWhereWithoutCheckerInput[]
    deleteMany?: EquipmentItemScalarWhereInput | EquipmentItemScalarWhereInput[]
  }

  export type VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput = {
    create?: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput> | VolunteerHourCreateWithoutVerifierInput[] | VolunteerHourUncheckedCreateWithoutVerifierInput[]
    connectOrCreate?: VolunteerHourCreateOrConnectWithoutVerifierInput | VolunteerHourCreateOrConnectWithoutVerifierInput[]
    upsert?: VolunteerHourUpsertWithWhereUniqueWithoutVerifierInput | VolunteerHourUpsertWithWhereUniqueWithoutVerifierInput[]
    createMany?: VolunteerHourCreateManyVerifierInputEnvelope
    set?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    disconnect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    delete?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    connect?: VolunteerHourWhereUniqueInput | VolunteerHourWhereUniqueInput[]
    update?: VolunteerHourUpdateWithWhereUniqueWithoutVerifierInput | VolunteerHourUpdateWithWhereUniqueWithoutVerifierInput[]
    updateMany?: VolunteerHourUpdateManyWithWhereWithoutVerifierInput | VolunteerHourUpdateManyWithWhereWithoutVerifierInput[]
    deleteMany?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
  }

  export type BurrowCreatephotosInput = {
    set: string[]
  }

  export type UserCreateNestedOneWithoutBurrowsInput = {
    create?: XOR<UserCreateWithoutBurrowsInput, UserUncheckedCreateWithoutBurrowsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBurrowsInput
    connect?: UserWhereUniqueInput
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumBurrowStatusFieldUpdateOperationsInput = {
    set?: $Enums.BurrowStatus
  }

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

  export type BurrowUpdatephotosInput = {
    set?: string[]
    push?: string | string[]
  }

  export type UserUpdateOneWithoutBurrowsNestedInput = {
    create?: XOR<UserCreateWithoutBurrowsInput, UserUncheckedCreateWithoutBurrowsInput>
    connectOrCreate?: UserCreateOrConnectWithoutBurrowsInput
    upsert?: UserUpsertWithoutBurrowsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutBurrowsInput, UserUpdateWithoutBurrowsInput>, UserUncheckedUpdateWithoutBurrowsInput>
  }

  export type UserCreateNestedOneWithoutDonationsInput = {
    create?: XOR<UserCreateWithoutDonationsInput, UserUncheckedCreateWithoutDonationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutDonationsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumDonationCampaignFieldUpdateOperationsInput = {
    set?: $Enums.DonationCampaign
  }

  export type UserUpdateOneWithoutDonationsNestedInput = {
    create?: XOR<UserCreateWithoutDonationsInput, UserUncheckedCreateWithoutDonationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutDonationsInput
    upsert?: UserUpsertWithoutDonationsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutDonationsInput, UserUpdateWithoutDonationsInput>, UserUncheckedUpdateWithoutDonationsInput>
  }

  export type UserCreateNestedOneWithoutSightingsInput = {
    create?: XOR<UserCreateWithoutSightingsInput, UserUncheckedCreateWithoutSightingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSightingsInput
    connect?: UserWhereUniqueInput
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type UserUpdateOneWithoutSightingsNestedInput = {
    create?: XOR<UserCreateWithoutSightingsInput, UserUncheckedCreateWithoutSightingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSightingsInput
    upsert?: UserUpsertWithoutSightingsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSightingsInput, UserUpdateWithoutSightingsInput>, UserUncheckedUpdateWithoutSightingsInput>
  }

  export type EventRSVPCreateNestedManyWithoutEventInput = {
    create?: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput> | EventRSVPCreateWithoutEventInput[] | EventRSVPUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutEventInput | EventRSVPCreateOrConnectWithoutEventInput[]
    createMany?: EventRSVPCreateManyEventInputEnvelope
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
  }

  export type EventRSVPUncheckedCreateNestedManyWithoutEventInput = {
    create?: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput> | EventRSVPCreateWithoutEventInput[] | EventRSVPUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutEventInput | EventRSVPCreateOrConnectWithoutEventInput[]
    createMany?: EventRSVPCreateManyEventInputEnvelope
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumEventTypeFieldUpdateOperationsInput = {
    set?: $Enums.EventType
  }

  export type EventRSVPUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput> | EventRSVPCreateWithoutEventInput[] | EventRSVPUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutEventInput | EventRSVPCreateOrConnectWithoutEventInput[]
    upsert?: EventRSVPUpsertWithWhereUniqueWithoutEventInput | EventRSVPUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventRSVPCreateManyEventInputEnvelope
    set?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    disconnect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    delete?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    update?: EventRSVPUpdateWithWhereUniqueWithoutEventInput | EventRSVPUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventRSVPUpdateManyWithWhereWithoutEventInput | EventRSVPUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
  }

  export type EventRSVPUncheckedUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput> | EventRSVPCreateWithoutEventInput[] | EventRSVPUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventRSVPCreateOrConnectWithoutEventInput | EventRSVPCreateOrConnectWithoutEventInput[]
    upsert?: EventRSVPUpsertWithWhereUniqueWithoutEventInput | EventRSVPUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventRSVPCreateManyEventInputEnvelope
    set?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    disconnect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    delete?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    connect?: EventRSVPWhereUniqueInput | EventRSVPWhereUniqueInput[]
    update?: EventRSVPUpdateWithWhereUniqueWithoutEventInput | EventRSVPUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventRSVPUpdateManyWithWhereWithoutEventInput | EventRSVPUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
  }

  export type EventCreateNestedOneWithoutRsvpsInput = {
    create?: XOR<EventCreateWithoutRsvpsInput, EventUncheckedCreateWithoutRsvpsInput>
    connectOrCreate?: EventCreateOrConnectWithoutRsvpsInput
    connect?: EventWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutEvent_rsvpsInput = {
    create?: XOR<UserCreateWithoutEvent_rsvpsInput, UserUncheckedCreateWithoutEvent_rsvpsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEvent_rsvpsInput
    connect?: UserWhereUniqueInput
  }

  export type EventUpdateOneRequiredWithoutRsvpsNestedInput = {
    create?: XOR<EventCreateWithoutRsvpsInput, EventUncheckedCreateWithoutRsvpsInput>
    connectOrCreate?: EventCreateOrConnectWithoutRsvpsInput
    upsert?: EventUpsertWithoutRsvpsInput
    connect?: EventWhereUniqueInput
    update?: XOR<XOR<EventUpdateToOneWithWhereWithoutRsvpsInput, EventUpdateWithoutRsvpsInput>, EventUncheckedUpdateWithoutRsvpsInput>
  }

  export type UserUpdateOneRequiredWithoutEvent_rsvpsNestedInput = {
    create?: XOR<UserCreateWithoutEvent_rsvpsInput, UserUncheckedCreateWithoutEvent_rsvpsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEvent_rsvpsInput
    upsert?: UserUpsertWithoutEvent_rsvpsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEvent_rsvpsInput, UserUpdateWithoutEvent_rsvpsInput>, UserUncheckedUpdateWithoutEvent_rsvpsInput>
  }

  export type EnumStreamStatusFieldUpdateOperationsInput = {
    set?: $Enums.StreamStatus
  }

  export type UserCreateNestedOneWithoutVolunteer_hoursInput = {
    create?: XOR<UserCreateWithoutVolunteer_hoursInput, UserUncheckedCreateWithoutVolunteer_hoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutVolunteer_hoursInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutVerified_hoursInput = {
    create?: XOR<UserCreateWithoutVerified_hoursInput, UserUncheckedCreateWithoutVerified_hoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutVerified_hoursInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutVolunteer_hoursNestedInput = {
    create?: XOR<UserCreateWithoutVolunteer_hoursInput, UserUncheckedCreateWithoutVolunteer_hoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutVolunteer_hoursInput
    upsert?: UserUpsertWithoutVolunteer_hoursInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutVolunteer_hoursInput, UserUpdateWithoutVolunteer_hoursInput>, UserUncheckedUpdateWithoutVolunteer_hoursInput>
  }

  export type UserUpdateOneWithoutVerified_hoursNestedInput = {
    create?: XOR<UserCreateWithoutVerified_hoursInput, UserUncheckedCreateWithoutVerified_hoursInput>
    connectOrCreate?: UserCreateOrConnectWithoutVerified_hoursInput
    upsert?: UserUpsertWithoutVerified_hoursInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutVerified_hoursInput, UserUpdateWithoutVerified_hoursInput>, UserUncheckedUpdateWithoutVerified_hoursInput>
  }

  export type UserCreateNestedOneWithoutEquipment_itemsInput = {
    create?: XOR<UserCreateWithoutEquipment_itemsInput, UserUncheckedCreateWithoutEquipment_itemsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEquipment_itemsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumEquipmentStatusFieldUpdateOperationsInput = {
    set?: $Enums.EquipmentStatus
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type UserUpdateOneWithoutEquipment_itemsNestedInput = {
    create?: XOR<UserCreateWithoutEquipment_itemsInput, UserUncheckedCreateWithoutEquipment_itemsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEquipment_itemsInput
    upsert?: UserUpsertWithoutEquipment_itemsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEquipment_itemsInput, UserUpdateWithoutEquipment_itemsInput>, UserUncheckedUpdateWithoutEquipment_itemsInput>
  }

  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 NestedEnumUserRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedEnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.UserRole | EnumUserRoleFieldRefInput<$PrismaModel>
    in?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.UserRole[] | ListEnumUserRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumUserRoleFilter<$PrismaModel>
    _max?: NestedEnumUserRoleFilter<$PrismaModel>
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type 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 NestedEnumBurrowStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.BurrowStatus | EnumBurrowStatusFieldRefInput<$PrismaModel>
    in?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumBurrowStatusFilter<$PrismaModel> | $Enums.BurrowStatus
  }

  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 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 NestedEnumBurrowStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.BurrowStatus | EnumBurrowStatusFieldRefInput<$PrismaModel>
    in?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.BurrowStatus[] | ListEnumBurrowStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumBurrowStatusWithAggregatesFilter<$PrismaModel> | $Enums.BurrowStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumBurrowStatusFilter<$PrismaModel>
    _max?: NestedEnumBurrowStatusFilter<$PrismaModel>
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedEnumDonationCampaignFilter<$PrismaModel = never> = {
    equals?: $Enums.DonationCampaign | EnumDonationCampaignFieldRefInput<$PrismaModel>
    in?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    notIn?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    not?: NestedEnumDonationCampaignFilter<$PrismaModel> | $Enums.DonationCampaign
  }

  export type NestedEnumDonationCampaignWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.DonationCampaign | EnumDonationCampaignFieldRefInput<$PrismaModel>
    in?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    notIn?: $Enums.DonationCampaign[] | ListEnumDonationCampaignFieldRefInput<$PrismaModel>
    not?: NestedEnumDonationCampaignWithAggregatesFilter<$PrismaModel> | $Enums.DonationCampaign
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumDonationCampaignFilter<$PrismaModel>
    _max?: NestedEnumDonationCampaignFilter<$PrismaModel>
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedEnumEventTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeFilter<$PrismaModel> | $Enums.EventType
  }

  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 NestedEnumEventTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeWithAggregatesFilter<$PrismaModel> | $Enums.EventType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEventTypeFilter<$PrismaModel>
    _max?: NestedEnumEventTypeFilter<$PrismaModel>
  }

  export type NestedEnumStreamStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.StreamStatus | EnumStreamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStreamStatusFilter<$PrismaModel> | $Enums.StreamStatus
  }

  export type NestedEnumStreamStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StreamStatus | EnumStreamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.StreamStatus[] | ListEnumStreamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumStreamStatusWithAggregatesFilter<$PrismaModel> | $Enums.StreamStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStreamStatusFilter<$PrismaModel>
    _max?: NestedEnumStreamStatusFilter<$PrismaModel>
  }

  export type NestedEnumEquipmentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.EquipmentStatus | EnumEquipmentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumEquipmentStatusFilter<$PrismaModel> | $Enums.EquipmentStatus
  }

  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 NestedEnumEquipmentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EquipmentStatus | EnumEquipmentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.EquipmentStatus[] | ListEnumEquipmentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumEquipmentStatusWithAggregatesFilter<$PrismaModel> | $Enums.EquipmentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEquipmentStatusFilter<$PrismaModel>
    _max?: NestedEnumEquipmentStatusFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type BurrowCreateWithoutAssigned_volunteerInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    created_at?: Date | string
  }

  export type BurrowUncheckedCreateWithoutAssigned_volunteerInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    created_at?: Date | string
  }

  export type BurrowCreateOrConnectWithoutAssigned_volunteerInput = {
    where: BurrowWhereUniqueInput
    create: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput>
  }

  export type BurrowCreateManyAssigned_volunteerInputEnvelope = {
    data: BurrowCreateManyAssigned_volunteerInput | BurrowCreateManyAssigned_volunteerInput[]
    skipDuplicates?: boolean
  }

  export type DonationCreateWithoutDonorInput = {
    id?: string
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
  }

  export type DonationUncheckedCreateWithoutDonorInput = {
    id?: string
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
  }

  export type DonationCreateOrConnectWithoutDonorInput = {
    where: DonationWhereUniqueInput
    create: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput>
  }

  export type DonationCreateManyDonorInputEnvelope = {
    data: DonationCreateManyDonorInput | DonationCreateManyDonorInput[]
    skipDuplicates?: boolean
  }

  export type WildlifeSightingCreateWithoutReporterInput = {
    id?: string
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
  }

  export type WildlifeSightingUncheckedCreateWithoutReporterInput = {
    id?: string
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
  }

  export type WildlifeSightingCreateOrConnectWithoutReporterInput = {
    where: WildlifeSightingWhereUniqueInput
    create: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput>
  }

  export type WildlifeSightingCreateManyReporterInputEnvelope = {
    data: WildlifeSightingCreateManyReporterInput | WildlifeSightingCreateManyReporterInput[]
    skipDuplicates?: boolean
  }

  export type EventRSVPCreateWithoutUserInput = {
    created_at?: Date | string
    event: EventCreateNestedOneWithoutRsvpsInput
  }

  export type EventRSVPUncheckedCreateWithoutUserInput = {
    event_id: string
    created_at?: Date | string
  }

  export type EventRSVPCreateOrConnectWithoutUserInput = {
    where: EventRSVPWhereUniqueInput
    create: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput>
  }

  export type EventRSVPCreateManyUserInputEnvelope = {
    data: EventRSVPCreateManyUserInput | EventRSVPCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type VolunteerHourCreateWithoutVolunteerInput = {
    id?: string
    date: Date | string
    hours: number
    task_description: string
    created_at?: Date | string
    verifier?: UserCreateNestedOneWithoutVerified_hoursInput
  }

  export type VolunteerHourUncheckedCreateWithoutVolunteerInput = {
    id?: string
    date: Date | string
    hours: number
    task_description: string
    verified_by?: string | null
    created_at?: Date | string
  }

  export type VolunteerHourCreateOrConnectWithoutVolunteerInput = {
    where: VolunteerHourWhereUniqueInput
    create: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput>
  }

  export type VolunteerHourCreateManyVolunteerInputEnvelope = {
    data: VolunteerHourCreateManyVolunteerInput | VolunteerHourCreateManyVolunteerInput[]
    skipDuplicates?: boolean
  }

  export type EquipmentItemCreateWithoutCheckerInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_at?: Date | string | null
    created_at?: Date | string
  }

  export type EquipmentItemUncheckedCreateWithoutCheckerInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_at?: Date | string | null
    created_at?: Date | string
  }

  export type EquipmentItemCreateOrConnectWithoutCheckerInput = {
    where: EquipmentItemWhereUniqueInput
    create: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput>
  }

  export type EquipmentItemCreateManyCheckerInputEnvelope = {
    data: EquipmentItemCreateManyCheckerInput | EquipmentItemCreateManyCheckerInput[]
    skipDuplicates?: boolean
  }

  export type VolunteerHourCreateWithoutVerifierInput = {
    id?: string
    date: Date | string
    hours: number
    task_description: string
    created_at?: Date | string
    volunteer: UserCreateNestedOneWithoutVolunteer_hoursInput
  }

  export type VolunteerHourUncheckedCreateWithoutVerifierInput = {
    id?: string
    volunteer_id: string
    date: Date | string
    hours: number
    task_description: string
    created_at?: Date | string
  }

  export type VolunteerHourCreateOrConnectWithoutVerifierInput = {
    where: VolunteerHourWhereUniqueInput
    create: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput>
  }

  export type VolunteerHourCreateManyVerifierInputEnvelope = {
    data: VolunteerHourCreateManyVerifierInput | VolunteerHourCreateManyVerifierInput[]
    skipDuplicates?: boolean
  }

  export type BurrowUpsertWithWhereUniqueWithoutAssigned_volunteerInput = {
    where: BurrowWhereUniqueInput
    update: XOR<BurrowUpdateWithoutAssigned_volunteerInput, BurrowUncheckedUpdateWithoutAssigned_volunteerInput>
    create: XOR<BurrowCreateWithoutAssigned_volunteerInput, BurrowUncheckedCreateWithoutAssigned_volunteerInput>
  }

  export type BurrowUpdateWithWhereUniqueWithoutAssigned_volunteerInput = {
    where: BurrowWhereUniqueInput
    data: XOR<BurrowUpdateWithoutAssigned_volunteerInput, BurrowUncheckedUpdateWithoutAssigned_volunteerInput>
  }

  export type BurrowUpdateManyWithWhereWithoutAssigned_volunteerInput = {
    where: BurrowScalarWhereInput
    data: XOR<BurrowUpdateManyMutationInput, BurrowUncheckedUpdateManyWithoutAssigned_volunteerInput>
  }

  export type BurrowScalarWhereInput = {
    AND?: BurrowScalarWhereInput | BurrowScalarWhereInput[]
    OR?: BurrowScalarWhereInput[]
    NOT?: BurrowScalarWhereInput | BurrowScalarWhereInput[]
    id?: StringFilter<"Burrow"> | string
    gps_lat?: FloatFilter<"Burrow"> | number
    gps_lng?: FloatFilter<"Burrow"> | number
    status?: EnumBurrowStatusFilter<"Burrow"> | $Enums.BurrowStatus
    location_description?: StringNullableFilter<"Burrow"> | string | null
    photos?: StringNullableListFilter<"Burrow">
    assigned_volunteer_id?: StringNullableFilter<"Burrow"> | string | null
    created_at?: DateTimeFilter<"Burrow"> | Date | string
  }

  export type DonationUpsertWithWhereUniqueWithoutDonorInput = {
    where: DonationWhereUniqueInput
    update: XOR<DonationUpdateWithoutDonorInput, DonationUncheckedUpdateWithoutDonorInput>
    create: XOR<DonationCreateWithoutDonorInput, DonationUncheckedCreateWithoutDonorInput>
  }

  export type DonationUpdateWithWhereUniqueWithoutDonorInput = {
    where: DonationWhereUniqueInput
    data: XOR<DonationUpdateWithoutDonorInput, DonationUncheckedUpdateWithoutDonorInput>
  }

  export type DonationUpdateManyWithWhereWithoutDonorInput = {
    where: DonationScalarWhereInput
    data: XOR<DonationUpdateManyMutationInput, DonationUncheckedUpdateManyWithoutDonorInput>
  }

  export type DonationScalarWhereInput = {
    AND?: DonationScalarWhereInput | DonationScalarWhereInput[]
    OR?: DonationScalarWhereInput[]
    NOT?: DonationScalarWhereInput | DonationScalarWhereInput[]
    id?: StringFilter<"Donation"> | string
    donor_id?: StringNullableFilter<"Donation"> | string | null
    amount?: FloatFilter<"Donation"> | number
    campaign?: EnumDonationCampaignFilter<"Donation"> | $Enums.DonationCampaign
    stripe_payment_id?: StringNullableFilter<"Donation"> | string | null
    created_at?: DateTimeFilter<"Donation"> | Date | string
  }

  export type WildlifeSightingUpsertWithWhereUniqueWithoutReporterInput = {
    where: WildlifeSightingWhereUniqueInput
    update: XOR<WildlifeSightingUpdateWithoutReporterInput, WildlifeSightingUncheckedUpdateWithoutReporterInput>
    create: XOR<WildlifeSightingCreateWithoutReporterInput, WildlifeSightingUncheckedCreateWithoutReporterInput>
  }

  export type WildlifeSightingUpdateWithWhereUniqueWithoutReporterInput = {
    where: WildlifeSightingWhereUniqueInput
    data: XOR<WildlifeSightingUpdateWithoutReporterInput, WildlifeSightingUncheckedUpdateWithoutReporterInput>
  }

  export type WildlifeSightingUpdateManyWithWhereWithoutReporterInput = {
    where: WildlifeSightingScalarWhereInput
    data: XOR<WildlifeSightingUpdateManyMutationInput, WildlifeSightingUncheckedUpdateManyWithoutReporterInput>
  }

  export type WildlifeSightingScalarWhereInput = {
    AND?: WildlifeSightingScalarWhereInput | WildlifeSightingScalarWhereInput[]
    OR?: WildlifeSightingScalarWhereInput[]
    NOT?: WildlifeSightingScalarWhereInput | WildlifeSightingScalarWhereInput[]
    id?: StringFilter<"WildlifeSighting"> | string
    reporter_id?: StringNullableFilter<"WildlifeSighting"> | string | null
    species?: StringFilter<"WildlifeSighting"> | string
    gps_lat?: FloatFilter<"WildlifeSighting"> | number
    gps_lng?: FloatFilter<"WildlifeSighting"> | number
    photo_url?: StringNullableFilter<"WildlifeSighting"> | string | null
    description?: StringNullableFilter<"WildlifeSighting"> | string | null
    verified?: BoolFilter<"WildlifeSighting"> | boolean
    created_at?: DateTimeFilter<"WildlifeSighting"> | Date | string
  }

  export type EventRSVPUpsertWithWhereUniqueWithoutUserInput = {
    where: EventRSVPWhereUniqueInput
    update: XOR<EventRSVPUpdateWithoutUserInput, EventRSVPUncheckedUpdateWithoutUserInput>
    create: XOR<EventRSVPCreateWithoutUserInput, EventRSVPUncheckedCreateWithoutUserInput>
  }

  export type EventRSVPUpdateWithWhereUniqueWithoutUserInput = {
    where: EventRSVPWhereUniqueInput
    data: XOR<EventRSVPUpdateWithoutUserInput, EventRSVPUncheckedUpdateWithoutUserInput>
  }

  export type EventRSVPUpdateManyWithWhereWithoutUserInput = {
    where: EventRSVPScalarWhereInput
    data: XOR<EventRSVPUpdateManyMutationInput, EventRSVPUncheckedUpdateManyWithoutUserInput>
  }

  export type EventRSVPScalarWhereInput = {
    AND?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
    OR?: EventRSVPScalarWhereInput[]
    NOT?: EventRSVPScalarWhereInput | EventRSVPScalarWhereInput[]
    event_id?: StringFilter<"EventRSVP"> | string
    user_id?: StringFilter<"EventRSVP"> | string
    created_at?: DateTimeFilter<"EventRSVP"> | Date | string
  }

  export type VolunteerHourUpsertWithWhereUniqueWithoutVolunteerInput = {
    where: VolunteerHourWhereUniqueInput
    update: XOR<VolunteerHourUpdateWithoutVolunteerInput, VolunteerHourUncheckedUpdateWithoutVolunteerInput>
    create: XOR<VolunteerHourCreateWithoutVolunteerInput, VolunteerHourUncheckedCreateWithoutVolunteerInput>
  }

  export type VolunteerHourUpdateWithWhereUniqueWithoutVolunteerInput = {
    where: VolunteerHourWhereUniqueInput
    data: XOR<VolunteerHourUpdateWithoutVolunteerInput, VolunteerHourUncheckedUpdateWithoutVolunteerInput>
  }

  export type VolunteerHourUpdateManyWithWhereWithoutVolunteerInput = {
    where: VolunteerHourScalarWhereInput
    data: XOR<VolunteerHourUpdateManyMutationInput, VolunteerHourUncheckedUpdateManyWithoutVolunteerInput>
  }

  export type VolunteerHourScalarWhereInput = {
    AND?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
    OR?: VolunteerHourScalarWhereInput[]
    NOT?: VolunteerHourScalarWhereInput | VolunteerHourScalarWhereInput[]
    id?: StringFilter<"VolunteerHour"> | string
    volunteer_id?: StringFilter<"VolunteerHour"> | string
    date?: DateTimeFilter<"VolunteerHour"> | Date | string
    hours?: FloatFilter<"VolunteerHour"> | number
    task_description?: StringFilter<"VolunteerHour"> | string
    verified_by?: StringNullableFilter<"VolunteerHour"> | string | null
    created_at?: DateTimeFilter<"VolunteerHour"> | Date | string
  }

  export type EquipmentItemUpsertWithWhereUniqueWithoutCheckerInput = {
    where: EquipmentItemWhereUniqueInput
    update: XOR<EquipmentItemUpdateWithoutCheckerInput, EquipmentItemUncheckedUpdateWithoutCheckerInput>
    create: XOR<EquipmentItemCreateWithoutCheckerInput, EquipmentItemUncheckedCreateWithoutCheckerInput>
  }

  export type EquipmentItemUpdateWithWhereUniqueWithoutCheckerInput = {
    where: EquipmentItemWhereUniqueInput
    data: XOR<EquipmentItemUpdateWithoutCheckerInput, EquipmentItemUncheckedUpdateWithoutCheckerInput>
  }

  export type EquipmentItemUpdateManyWithWhereWithoutCheckerInput = {
    where: EquipmentItemScalarWhereInput
    data: XOR<EquipmentItemUpdateManyMutationInput, EquipmentItemUncheckedUpdateManyWithoutCheckerInput>
  }

  export type EquipmentItemScalarWhereInput = {
    AND?: EquipmentItemScalarWhereInput | EquipmentItemScalarWhereInput[]
    OR?: EquipmentItemScalarWhereInput[]
    NOT?: EquipmentItemScalarWhereInput | EquipmentItemScalarWhereInput[]
    id?: StringFilter<"EquipmentItem"> | string
    name?: StringFilter<"EquipmentItem"> | string
    description?: StringNullableFilter<"EquipmentItem"> | string | null
    status?: EnumEquipmentStatusFilter<"EquipmentItem"> | $Enums.EquipmentStatus
    checked_out_by?: StringNullableFilter<"EquipmentItem"> | string | null
    checked_out_at?: DateTimeNullableFilter<"EquipmentItem"> | Date | string | null
    created_at?: DateTimeFilter<"EquipmentItem"> | Date | string
  }

  export type VolunteerHourUpsertWithWhereUniqueWithoutVerifierInput = {
    where: VolunteerHourWhereUniqueInput
    update: XOR<VolunteerHourUpdateWithoutVerifierInput, VolunteerHourUncheckedUpdateWithoutVerifierInput>
    create: XOR<VolunteerHourCreateWithoutVerifierInput, VolunteerHourUncheckedCreateWithoutVerifierInput>
  }

  export type VolunteerHourUpdateWithWhereUniqueWithoutVerifierInput = {
    where: VolunteerHourWhereUniqueInput
    data: XOR<VolunteerHourUpdateWithoutVerifierInput, VolunteerHourUncheckedUpdateWithoutVerifierInput>
  }

  export type VolunteerHourUpdateManyWithWhereWithoutVerifierInput = {
    where: VolunteerHourScalarWhereInput
    data: XOR<VolunteerHourUpdateManyMutationInput, VolunteerHourUncheckedUpdateManyWithoutVerifierInput>
  }

  export type UserCreateWithoutBurrowsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutBurrowsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutBurrowsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutBurrowsInput, UserUncheckedCreateWithoutBurrowsInput>
  }

  export type UserUpsertWithoutBurrowsInput = {
    update: XOR<UserUpdateWithoutBurrowsInput, UserUncheckedUpdateWithoutBurrowsInput>
    create: XOR<UserCreateWithoutBurrowsInput, UserUncheckedCreateWithoutBurrowsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutBurrowsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutBurrowsInput, UserUncheckedUpdateWithoutBurrowsInput>
  }

  export type UserUpdateWithoutBurrowsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutBurrowsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type UserCreateWithoutDonationsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutDonationsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutDonationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutDonationsInput, UserUncheckedCreateWithoutDonationsInput>
  }

  export type UserUpsertWithoutDonationsInput = {
    update: XOR<UserUpdateWithoutDonationsInput, UserUncheckedUpdateWithoutDonationsInput>
    create: XOR<UserCreateWithoutDonationsInput, UserUncheckedCreateWithoutDonationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutDonationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutDonationsInput, UserUncheckedUpdateWithoutDonationsInput>
  }

  export type UserUpdateWithoutDonationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutDonationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type UserCreateWithoutSightingsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutSightingsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutSightingsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSightingsInput, UserUncheckedCreateWithoutSightingsInput>
  }

  export type UserUpsertWithoutSightingsInput = {
    update: XOR<UserUpdateWithoutSightingsInput, UserUncheckedUpdateWithoutSightingsInput>
    create: XOR<UserCreateWithoutSightingsInput, UserUncheckedCreateWithoutSightingsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSightingsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSightingsInput, UserUncheckedUpdateWithoutSightingsInput>
  }

  export type UserUpdateWithoutSightingsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutSightingsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type EventRSVPCreateWithoutEventInput = {
    created_at?: Date | string
    user: UserCreateNestedOneWithoutEvent_rsvpsInput
  }

  export type EventRSVPUncheckedCreateWithoutEventInput = {
    user_id: string
    created_at?: Date | string
  }

  export type EventRSVPCreateOrConnectWithoutEventInput = {
    where: EventRSVPWhereUniqueInput
    create: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput>
  }

  export type EventRSVPCreateManyEventInputEnvelope = {
    data: EventRSVPCreateManyEventInput | EventRSVPCreateManyEventInput[]
    skipDuplicates?: boolean
  }

  export type EventRSVPUpsertWithWhereUniqueWithoutEventInput = {
    where: EventRSVPWhereUniqueInput
    update: XOR<EventRSVPUpdateWithoutEventInput, EventRSVPUncheckedUpdateWithoutEventInput>
    create: XOR<EventRSVPCreateWithoutEventInput, EventRSVPUncheckedCreateWithoutEventInput>
  }

  export type EventRSVPUpdateWithWhereUniqueWithoutEventInput = {
    where: EventRSVPWhereUniqueInput
    data: XOR<EventRSVPUpdateWithoutEventInput, EventRSVPUncheckedUpdateWithoutEventInput>
  }

  export type EventRSVPUpdateManyWithWhereWithoutEventInput = {
    where: EventRSVPScalarWhereInput
    data: XOR<EventRSVPUpdateManyMutationInput, EventRSVPUncheckedUpdateManyWithoutEventInput>
  }

  export type EventCreateWithoutRsvpsInput = {
    id?: string
    title: string
    description?: string | null
    date: Date | string
    location: string
    max_attendees?: number | null
    type: $Enums.EventType
    created_at?: Date | string
  }

  export type EventUncheckedCreateWithoutRsvpsInput = {
    id?: string
    title: string
    description?: string | null
    date: Date | string
    location: string
    max_attendees?: number | null
    type: $Enums.EventType
    created_at?: Date | string
  }

  export type EventCreateOrConnectWithoutRsvpsInput = {
    where: EventWhereUniqueInput
    create: XOR<EventCreateWithoutRsvpsInput, EventUncheckedCreateWithoutRsvpsInput>
  }

  export type UserCreateWithoutEvent_rsvpsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutEvent_rsvpsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutEvent_rsvpsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEvent_rsvpsInput, UserUncheckedCreateWithoutEvent_rsvpsInput>
  }

  export type EventUpsertWithoutRsvpsInput = {
    update: XOR<EventUpdateWithoutRsvpsInput, EventUncheckedUpdateWithoutRsvpsInput>
    create: XOR<EventCreateWithoutRsvpsInput, EventUncheckedCreateWithoutRsvpsInput>
    where?: EventWhereInput
  }

  export type EventUpdateToOneWithWhereWithoutRsvpsInput = {
    where?: EventWhereInput
    data: XOR<EventUpdateWithoutRsvpsInput, EventUncheckedUpdateWithoutRsvpsInput>
  }

  export type EventUpdateWithoutRsvpsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventUncheckedUpdateWithoutRsvpsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    location?: StringFieldUpdateOperationsInput | string
    max_attendees?: NullableIntFieldUpdateOperationsInput | number | null
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUpsertWithoutEvent_rsvpsInput = {
    update: XOR<UserUpdateWithoutEvent_rsvpsInput, UserUncheckedUpdateWithoutEvent_rsvpsInput>
    create: XOR<UserCreateWithoutEvent_rsvpsInput, UserUncheckedCreateWithoutEvent_rsvpsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEvent_rsvpsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEvent_rsvpsInput, UserUncheckedUpdateWithoutEvent_rsvpsInput>
  }

  export type UserUpdateWithoutEvent_rsvpsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutEvent_rsvpsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type UserCreateWithoutVolunteer_hoursInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutVolunteer_hoursInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutVolunteer_hoursInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutVolunteer_hoursInput, UserUncheckedCreateWithoutVolunteer_hoursInput>
  }

  export type UserCreateWithoutVerified_hoursInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemCreateNestedManyWithoutCheckerInput
  }

  export type UserUncheckedCreateWithoutVerified_hoursInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    equipment_items?: EquipmentItemUncheckedCreateNestedManyWithoutCheckerInput
  }

  export type UserCreateOrConnectWithoutVerified_hoursInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutVerified_hoursInput, UserUncheckedCreateWithoutVerified_hoursInput>
  }

  export type UserUpsertWithoutVolunteer_hoursInput = {
    update: XOR<UserUpdateWithoutVolunteer_hoursInput, UserUncheckedUpdateWithoutVolunteer_hoursInput>
    create: XOR<UserCreateWithoutVolunteer_hoursInput, UserUncheckedCreateWithoutVolunteer_hoursInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutVolunteer_hoursInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutVolunteer_hoursInput, UserUncheckedUpdateWithoutVolunteer_hoursInput>
  }

  export type UserUpdateWithoutVolunteer_hoursInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutVolunteer_hoursInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type UserUpsertWithoutVerified_hoursInput = {
    update: XOR<UserUpdateWithoutVerified_hoursInput, UserUncheckedUpdateWithoutVerified_hoursInput>
    create: XOR<UserCreateWithoutVerified_hoursInput, UserUncheckedCreateWithoutVerified_hoursInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutVerified_hoursInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutVerified_hoursInput, UserUncheckedUpdateWithoutVerified_hoursInput>
  }

  export type UserUpdateWithoutVerified_hoursInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUpdateManyWithoutCheckerNestedInput
  }

  export type UserUncheckedUpdateWithoutVerified_hoursInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    equipment_items?: EquipmentItemUncheckedUpdateManyWithoutCheckerNestedInput
  }

  export type UserCreateWithoutEquipment_itemsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourCreateNestedManyWithoutVolunteerInput
    verified_hours?: VolunteerHourCreateNestedManyWithoutVerifierInput
  }

  export type UserUncheckedCreateWithoutEquipment_itemsInput = {
    id?: string
    email: string
    name: string
    role?: $Enums.UserRole
    password_hash: string
    created_at?: Date | string
    burrows?: BurrowUncheckedCreateNestedManyWithoutAssigned_volunteerInput
    donations?: DonationUncheckedCreateNestedManyWithoutDonorInput
    sightings?: WildlifeSightingUncheckedCreateNestedManyWithoutReporterInput
    event_rsvps?: EventRSVPUncheckedCreateNestedManyWithoutUserInput
    volunteer_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVolunteerInput
    verified_hours?: VolunteerHourUncheckedCreateNestedManyWithoutVerifierInput
  }

  export type UserCreateOrConnectWithoutEquipment_itemsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEquipment_itemsInput, UserUncheckedCreateWithoutEquipment_itemsInput>
  }

  export type UserUpsertWithoutEquipment_itemsInput = {
    update: XOR<UserUpdateWithoutEquipment_itemsInput, UserUncheckedUpdateWithoutEquipment_itemsInput>
    create: XOR<UserCreateWithoutEquipment_itemsInput, UserUncheckedCreateWithoutEquipment_itemsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEquipment_itemsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEquipment_itemsInput, UserUncheckedUpdateWithoutEquipment_itemsInput>
  }

  export type UserUpdateWithoutEquipment_itemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUpdateManyWithoutVolunteerNestedInput
    verified_hours?: VolunteerHourUpdateManyWithoutVerifierNestedInput
  }

  export type UserUncheckedUpdateWithoutEquipment_itemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    role?: EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
    password_hash?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    burrows?: BurrowUncheckedUpdateManyWithoutAssigned_volunteerNestedInput
    donations?: DonationUncheckedUpdateManyWithoutDonorNestedInput
    sightings?: WildlifeSightingUncheckedUpdateManyWithoutReporterNestedInput
    event_rsvps?: EventRSVPUncheckedUpdateManyWithoutUserNestedInput
    volunteer_hours?: VolunteerHourUncheckedUpdateManyWithoutVolunteerNestedInput
    verified_hours?: VolunteerHourUncheckedUpdateManyWithoutVerifierNestedInput
  }

  export type BurrowCreateManyAssigned_volunteerInput = {
    id?: string
    gps_lat: number
    gps_lng: number
    status?: $Enums.BurrowStatus
    location_description?: string | null
    photos?: BurrowCreatephotosInput | string[]
    created_at?: Date | string
  }

  export type DonationCreateManyDonorInput = {
    id?: string
    amount: number
    campaign?: $Enums.DonationCampaign
    stripe_payment_id?: string | null
    created_at?: Date | string
  }

  export type WildlifeSightingCreateManyReporterInput = {
    id?: string
    species: string
    gps_lat: number
    gps_lng: number
    photo_url?: string | null
    description?: string | null
    verified?: boolean
    created_at?: Date | string
  }

  export type EventRSVPCreateManyUserInput = {
    event_id: string
    created_at?: Date | string
  }

  export type VolunteerHourCreateManyVolunteerInput = {
    id?: string
    date: Date | string
    hours: number
    task_description: string
    verified_by?: string | null
    created_at?: Date | string
  }

  export type EquipmentItemCreateManyCheckerInput = {
    id?: string
    name: string
    description?: string | null
    status?: $Enums.EquipmentStatus
    checked_out_at?: Date | string | null
    created_at?: Date | string
  }

  export type VolunteerHourCreateManyVerifierInput = {
    id?: string
    volunteer_id: string
    date: Date | string
    hours: number
    task_description: string
    created_at?: Date | string
  }

  export type BurrowUpdateWithoutAssigned_volunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BurrowUncheckedUpdateWithoutAssigned_volunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BurrowUncheckedUpdateManyWithoutAssigned_volunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    status?: EnumBurrowStatusFieldUpdateOperationsInput | $Enums.BurrowStatus
    location_description?: NullableStringFieldUpdateOperationsInput | string | null
    photos?: BurrowUpdatephotosInput | string[]
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationUpdateWithoutDonorInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationUncheckedUpdateWithoutDonorInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DonationUncheckedUpdateManyWithoutDonorInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: FloatFieldUpdateOperationsInput | number
    campaign?: EnumDonationCampaignFieldUpdateOperationsInput | $Enums.DonationCampaign
    stripe_payment_id?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingUpdateWithoutReporterInput = {
    id?: StringFieldUpdateOperationsInput | string
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingUncheckedUpdateWithoutReporterInput = {
    id?: StringFieldUpdateOperationsInput | string
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WildlifeSightingUncheckedUpdateManyWithoutReporterInput = {
    id?: StringFieldUpdateOperationsInput | string
    species?: StringFieldUpdateOperationsInput | string
    gps_lat?: FloatFieldUpdateOperationsInput | number
    gps_lng?: FloatFieldUpdateOperationsInput | number
    photo_url?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPUpdateWithoutUserInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    event?: EventUpdateOneRequiredWithoutRsvpsNestedInput
  }

  export type EventRSVPUncheckedUpdateWithoutUserInput = {
    event_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPUncheckedUpdateManyWithoutUserInput = {
    event_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourUpdateWithoutVolunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    verifier?: UserUpdateOneWithoutVerified_hoursNestedInput
  }

  export type VolunteerHourUncheckedUpdateWithoutVolunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    verified_by?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourUncheckedUpdateManyWithoutVolunteerInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    verified_by?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemUpdateWithoutCheckerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemUncheckedUpdateWithoutCheckerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentItemUncheckedUpdateManyWithoutCheckerInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumEquipmentStatusFieldUpdateOperationsInput | $Enums.EquipmentStatus
    checked_out_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourUpdateWithoutVerifierInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    volunteer?: UserUpdateOneRequiredWithoutVolunteer_hoursNestedInput
  }

  export type VolunteerHourUncheckedUpdateWithoutVerifierInput = {
    id?: StringFieldUpdateOperationsInput | string
    volunteer_id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VolunteerHourUncheckedUpdateManyWithoutVerifierInput = {
    id?: StringFieldUpdateOperationsInput | string
    volunteer_id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    hours?: FloatFieldUpdateOperationsInput | number
    task_description?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPCreateManyEventInput = {
    user_id: string
    created_at?: Date | string
  }

  export type EventRSVPUpdateWithoutEventInput = {
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutEvent_rsvpsNestedInput
  }

  export type EventRSVPUncheckedUpdateWithoutEventInput = {
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventRSVPUncheckedUpdateManyWithoutEventInput = {
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventCountOutputTypeDefaultArgs instead
     */
    export type EventCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BurrowDefaultArgs instead
     */
    export type BurrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BurrowDefaultArgs<ExtArgs>
    /**
     * @deprecated Use DonationDefaultArgs instead
     */
    export type DonationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = DonationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WildlifeSightingDefaultArgs instead
     */
    export type WildlifeSightingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WildlifeSightingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventDefaultArgs instead
     */
    export type EventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventRSVPDefaultArgs instead
     */
    export type EventRSVPArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventRSVPDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LivestreamSourceDefaultArgs instead
     */
    export type LivestreamSourceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LivestreamSourceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VolunteerHourDefaultArgs instead
     */
    export type VolunteerHourArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VolunteerHourDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EquipmentItemDefaultArgs instead
     */
    export type EquipmentItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EquipmentItemDefaultArgs<ExtArgs>

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

  export type BatchPayload = {
    count: number
  }

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