
/**
 * 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 Ccis
 * 
 */
export type Ccis = $Result.DefaultSelection<Prisma.$CcisPayload>
/**
 * Model Turnover
 * 
 */
export type Turnover = $Result.DefaultSelection<Prisma.$TurnoverPayload>
/**
 * Model NEmployees
 * 
 */
export type NEmployees = $Result.DefaultSelection<Prisma.$NEmployeesPayload>
/**
 * Model City
 * 
 */
export type City = $Result.DefaultSelection<Prisma.$CityPayload>
/**
 * Model Position
 * 
 */
export type Position = $Result.DefaultSelection<Prisma.$PositionPayload>
/**
 * Model ActivityFamily
 * 
 */
export type ActivityFamily = $Result.DefaultSelection<Prisma.$ActivityFamilyPayload>
/**
 * Model Activity
 * 
 */
export type Activity = $Result.DefaultSelection<Prisma.$ActivityPayload>
/**
 * Model ExpertiseArea
 * 
 */
export type ExpertiseArea = $Result.DefaultSelection<Prisma.$ExpertiseAreaPayload>
/**
 * Model InterestArea
 * 
 */
export type InterestArea = $Result.DefaultSelection<Prisma.$InterestAreaPayload>
/**
 * Model Province
 * 
 */
export type Province = $Result.DefaultSelection<Prisma.$ProvincePayload>
/**
 * Model Category
 * 
 */
export type Category = $Result.DefaultSelection<Prisma.$CategoryPayload>
/**
 * Model Commission
 * 
 */
export type Commission = $Result.DefaultSelection<Prisma.$CommissionPayload>
/**
 * Model Mandate
 * 
 */
export type Mandate = $Result.DefaultSelection<Prisma.$MandatePayload>
/**
 * Model College
 * 
 */
export type College = $Result.DefaultSelection<Prisma.$CollegePayload>
/**
 * Model ElectedMember
 * 
 */
export type ElectedMember = $Result.DefaultSelection<Prisma.$ElectedMemberPayload>
/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model Notification
 * 
 */
export type Notification = $Result.DefaultSelection<Prisma.$NotificationPayload>
/**
 * Model Company
 * 
 */
export type Company = $Result.DefaultSelection<Prisma.$CompanyPayload>
/**
 * Model Connection
 * 
 */
export type Connection = $Result.DefaultSelection<Prisma.$ConnectionPayload>
/**
 * Model Message
 * 
 */
export type Message = $Result.DefaultSelection<Prisma.$MessagePayload>
/**
 * Model Opportunity
 * 
 */
export type Opportunity = $Result.DefaultSelection<Prisma.$OpportunityPayload>
/**
 * Model OpportunityLike
 * 
 */
export type OpportunityLike = $Result.DefaultSelection<Prisma.$OpportunityLikePayload>
/**
 * Model OpportunityComment
 * 
 */
export type OpportunityComment = $Result.DefaultSelection<Prisma.$OpportunityCommentPayload>
/**
 * Model Event
 * 
 */
export type Event = $Result.DefaultSelection<Prisma.$EventPayload>
/**
 * Model EventLike
 * 
 */
export type EventLike = $Result.DefaultSelection<Prisma.$EventLikePayload>
/**
 * Model EventComment
 * 
 */
export type EventComment = $Result.DefaultSelection<Prisma.$EventCommentPayload>
/**
 * Model Appointment
 * 
 */
export type Appointment = $Result.DefaultSelection<Prisma.$AppointmentPayload>
/**
 * Model AppointmentLike
 * 
 */
export type AppointmentLike = $Result.DefaultSelection<Prisma.$AppointmentLikePayload>
/**
 * Model AppointmentComment
 * 
 */
export type AppointmentComment = $Result.DefaultSelection<Prisma.$AppointmentCommentPayload>
/**
 * Model AppointmentRegistration
 * 
 */
export type AppointmentRegistration = $Result.DefaultSelection<Prisma.$AppointmentRegistrationPayload>
/**
 * Model Album
 * 
 */
export type Album = $Result.DefaultSelection<Prisma.$AlbumPayload>
/**
 * Model Video
 * 
 */
export type Video = $Result.DefaultSelection<Prisma.$VideoPayload>
/**
 * Model Edition
 * 
 */
export type Edition = $Result.DefaultSelection<Prisma.$EditionPayload>
/**
 * Model Training
 * 
 */
export type Training = $Result.DefaultSelection<Prisma.$TrainingPayload>
/**
 * Model Fair
 * 
 */
export type Fair = $Result.DefaultSelection<Prisma.$FairPayload>
/**
 * Model BusinessPlan
 * 
 */
export type BusinessPlan = $Result.DefaultSelection<Prisma.$BusinessPlanPayload>
/**
 * Model MarketResearch
 * 
 */
export type MarketResearch = $Result.DefaultSelection<Prisma.$MarketResearchPayload>
/**
 * Model Networking
 * 
 */
export type Networking = $Result.DefaultSelection<Prisma.$NetworkingPayload>
/**
 * Model Sourcing
 * 
 */
export type Sourcing = $Result.DefaultSelection<Prisma.$SourcingPayload>
/**
 * Model Prospecting
 * 
 */
export type Prospecting = $Result.DefaultSelection<Prisma.$ProspectingPayload>
/**
 * Model SmsLog
 * 
 */
export type SmsLog = $Result.DefaultSelection<Prisma.$SmsLogPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const Civility: {
  Mme: 'Mme',
  M: 'M'
};

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


export const Role: {
  User: 'User',
  Admin: 'Admin',
  SubAdmin: 'SubAdmin',
  ElectedMember: 'ElectedMember'
};

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


export const Permission: {
  Users: 'Users',
  Companies: 'Companies',
  Opportunities: 'Opportunities',
  ElectedMembers: 'ElectedMembers',
  Events: 'Events',
  Appointments: 'Appointments',
  Albums: 'Albums',
  Videos: 'Videos',
  Editions: 'Editions',
  Trainings: 'Trainings',
  Fairs: 'Fairs',
  Services: 'Services',
  Settings: 'Settings',
  CCIS: 'CCIS'
};

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


export const Source: {
  Administration: 'Administration',
  Chat: 'Chat',
  Networking: 'Networking'
};

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


export const LegalForm: {
  SA: 'SA',
  SARL: 'SARL',
  SNC: 'SNC',
  PPH: 'PPH',
  Autre: 'Autre'
};

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


export const TrainingType: {
  Payante: 'Payante',
  Gratuite: 'Gratuite'
};

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

}

export type Civility = $Enums.Civility

export const Civility: typeof $Enums.Civility

export type Role = $Enums.Role

export const Role: typeof $Enums.Role

export type Permission = $Enums.Permission

export const Permission: typeof $Enums.Permission

export type Source = $Enums.Source

export const Source: typeof $Enums.Source

export type LegalForm = $Enums.LegalForm

export const LegalForm: typeof $Enums.LegalForm

export type TrainingType = $Enums.TrainingType

export const TrainingType: typeof $Enums.TrainingType

/**
 * ##  Prisma Client ʲˢ
 * 
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Ccis
 * const ccis = await prisma.ccis.findMany()
 * ```
 *
 * 
 * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
 */
export class PrismaClient<
  T extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  U = 'log' extends keyof T ? T['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<T['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 Ccis
   * const ccis = await prisma.ccis.findMany()
   * ```
   *
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
   */

  constructor(optionsArg ?: Prisma.Subset<T, 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.ccis`: Exposes CRUD operations for the **Ccis** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Ccis
    * const ccis = await prisma.ccis.findMany()
    * ```
    */
  get ccis(): Prisma.CcisDelegate<ExtArgs>;

  /**
   * `prisma.turnover`: Exposes CRUD operations for the **Turnover** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Turnovers
    * const turnovers = await prisma.turnover.findMany()
    * ```
    */
  get turnover(): Prisma.TurnoverDelegate<ExtArgs>;

  /**
   * `prisma.nEmployees`: Exposes CRUD operations for the **NEmployees** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more NEmployees
    * const nEmployees = await prisma.nEmployees.findMany()
    * ```
    */
  get nEmployees(): Prisma.NEmployeesDelegate<ExtArgs>;

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

  /**
   * `prisma.position`: Exposes CRUD operations for the **Position** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Positions
    * const positions = await prisma.position.findMany()
    * ```
    */
  get position(): Prisma.PositionDelegate<ExtArgs>;

  /**
   * `prisma.activityFamily`: Exposes CRUD operations for the **ActivityFamily** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ActivityFamilies
    * const activityFamilies = await prisma.activityFamily.findMany()
    * ```
    */
  get activityFamily(): Prisma.ActivityFamilyDelegate<ExtArgs>;

  /**
   * `prisma.activity`: Exposes CRUD operations for the **Activity** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Activities
    * const activities = await prisma.activity.findMany()
    * ```
    */
  get activity(): Prisma.ActivityDelegate<ExtArgs>;

  /**
   * `prisma.expertiseArea`: Exposes CRUD operations for the **ExpertiseArea** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExpertiseAreas
    * const expertiseAreas = await prisma.expertiseArea.findMany()
    * ```
    */
  get expertiseArea(): Prisma.ExpertiseAreaDelegate<ExtArgs>;

  /**
   * `prisma.interestArea`: Exposes CRUD operations for the **InterestArea** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more InterestAreas
    * const interestAreas = await prisma.interestArea.findMany()
    * ```
    */
  get interestArea(): Prisma.InterestAreaDelegate<ExtArgs>;

  /**
   * `prisma.province`: Exposes CRUD operations for the **Province** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Provinces
    * const provinces = await prisma.province.findMany()
    * ```
    */
  get province(): Prisma.ProvinceDelegate<ExtArgs>;

  /**
   * `prisma.category`: Exposes CRUD operations for the **Category** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Categories
    * const categories = await prisma.category.findMany()
    * ```
    */
  get category(): Prisma.CategoryDelegate<ExtArgs>;

  /**
   * `prisma.commission`: Exposes CRUD operations for the **Commission** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Commissions
    * const commissions = await prisma.commission.findMany()
    * ```
    */
  get commission(): Prisma.CommissionDelegate<ExtArgs>;

  /**
   * `prisma.mandate`: Exposes CRUD operations for the **Mandate** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Mandates
    * const mandates = await prisma.mandate.findMany()
    * ```
    */
  get mandate(): Prisma.MandateDelegate<ExtArgs>;

  /**
   * `prisma.college`: Exposes CRUD operations for the **College** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Colleges
    * const colleges = await prisma.college.findMany()
    * ```
    */
  get college(): Prisma.CollegeDelegate<ExtArgs>;

  /**
   * `prisma.electedMember`: Exposes CRUD operations for the **ElectedMember** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ElectedMembers
    * const electedMembers = await prisma.electedMember.findMany()
    * ```
    */
  get electedMember(): Prisma.ElectedMemberDelegate<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.notification`: Exposes CRUD operations for the **Notification** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Notifications
    * const notifications = await prisma.notification.findMany()
    * ```
    */
  get notification(): Prisma.NotificationDelegate<ExtArgs>;

  /**
   * `prisma.company`: Exposes CRUD operations for the **Company** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Companies
    * const companies = await prisma.company.findMany()
    * ```
    */
  get company(): Prisma.CompanyDelegate<ExtArgs>;

  /**
   * `prisma.connection`: Exposes CRUD operations for the **Connection** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Connections
    * const connections = await prisma.connection.findMany()
    * ```
    */
  get connection(): Prisma.ConnectionDelegate<ExtArgs>;

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

  /**
   * `prisma.opportunity`: Exposes CRUD operations for the **Opportunity** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Opportunities
    * const opportunities = await prisma.opportunity.findMany()
    * ```
    */
  get opportunity(): Prisma.OpportunityDelegate<ExtArgs>;

  /**
   * `prisma.opportunityLike`: Exposes CRUD operations for the **OpportunityLike** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more OpportunityLikes
    * const opportunityLikes = await prisma.opportunityLike.findMany()
    * ```
    */
  get opportunityLike(): Prisma.OpportunityLikeDelegate<ExtArgs>;

  /**
   * `prisma.opportunityComment`: Exposes CRUD operations for the **OpportunityComment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more OpportunityComments
    * const opportunityComments = await prisma.opportunityComment.findMany()
    * ```
    */
  get opportunityComment(): Prisma.OpportunityCommentDelegate<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.eventLike`: Exposes CRUD operations for the **EventLike** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more EventLikes
    * const eventLikes = await prisma.eventLike.findMany()
    * ```
    */
  get eventLike(): Prisma.EventLikeDelegate<ExtArgs>;

  /**
   * `prisma.eventComment`: Exposes CRUD operations for the **EventComment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more EventComments
    * const eventComments = await prisma.eventComment.findMany()
    * ```
    */
  get eventComment(): Prisma.EventCommentDelegate<ExtArgs>;

  /**
   * `prisma.appointment`: Exposes CRUD operations for the **Appointment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Appointments
    * const appointments = await prisma.appointment.findMany()
    * ```
    */
  get appointment(): Prisma.AppointmentDelegate<ExtArgs>;

  /**
   * `prisma.appointmentLike`: Exposes CRUD operations for the **AppointmentLike** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppointmentLikes
    * const appointmentLikes = await prisma.appointmentLike.findMany()
    * ```
    */
  get appointmentLike(): Prisma.AppointmentLikeDelegate<ExtArgs>;

  /**
   * `prisma.appointmentComment`: Exposes CRUD operations for the **AppointmentComment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppointmentComments
    * const appointmentComments = await prisma.appointmentComment.findMany()
    * ```
    */
  get appointmentComment(): Prisma.AppointmentCommentDelegate<ExtArgs>;

  /**
   * `prisma.appointmentRegistration`: Exposes CRUD operations for the **AppointmentRegistration** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppointmentRegistrations
    * const appointmentRegistrations = await prisma.appointmentRegistration.findMany()
    * ```
    */
  get appointmentRegistration(): Prisma.AppointmentRegistrationDelegate<ExtArgs>;

  /**
   * `prisma.album`: Exposes CRUD operations for the **Album** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Albums
    * const albums = await prisma.album.findMany()
    * ```
    */
  get album(): Prisma.AlbumDelegate<ExtArgs>;

  /**
   * `prisma.video`: Exposes CRUD operations for the **Video** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Videos
    * const videos = await prisma.video.findMany()
    * ```
    */
  get video(): Prisma.VideoDelegate<ExtArgs>;

  /**
   * `prisma.edition`: Exposes CRUD operations for the **Edition** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Editions
    * const editions = await prisma.edition.findMany()
    * ```
    */
  get edition(): Prisma.EditionDelegate<ExtArgs>;

  /**
   * `prisma.training`: Exposes CRUD operations for the **Training** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Trainings
    * const trainings = await prisma.training.findMany()
    * ```
    */
  get training(): Prisma.TrainingDelegate<ExtArgs>;

  /**
   * `prisma.fair`: Exposes CRUD operations for the **Fair** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Fairs
    * const fairs = await prisma.fair.findMany()
    * ```
    */
  get fair(): Prisma.FairDelegate<ExtArgs>;

  /**
   * `prisma.businessPlan`: Exposes CRUD operations for the **BusinessPlan** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more BusinessPlans
    * const businessPlans = await prisma.businessPlan.findMany()
    * ```
    */
  get businessPlan(): Prisma.BusinessPlanDelegate<ExtArgs>;

  /**
   * `prisma.marketResearch`: Exposes CRUD operations for the **MarketResearch** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MarketResearches
    * const marketResearches = await prisma.marketResearch.findMany()
    * ```
    */
  get marketResearch(): Prisma.MarketResearchDelegate<ExtArgs>;

  /**
   * `prisma.networking`: Exposes CRUD operations for the **Networking** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Networkings
    * const networkings = await prisma.networking.findMany()
    * ```
    */
  get networking(): Prisma.NetworkingDelegate<ExtArgs>;

  /**
   * `prisma.sourcing`: Exposes CRUD operations for the **Sourcing** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Sourcings
    * const sourcings = await prisma.sourcing.findMany()
    * ```
    */
  get sourcing(): Prisma.SourcingDelegate<ExtArgs>;

  /**
   * `prisma.prospecting`: Exposes CRUD operations for the **Prospecting** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Prospectings
    * const prospectings = await prisma.prospecting.findMany()
    * ```
    */
  get prospecting(): Prisma.ProspectingDelegate<ExtArgs>;

  /**
   * `prisma.smsLog`: Exposes CRUD operations for the **SmsLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SmsLogs
    * const smsLogs = await prisma.smsLog.findMany()
    * ```
    */
  get smsLog(): Prisma.SmsLogDelegate<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.13.0
   * Query Engine version: 06fc58a368dc7be9fbbbe894adf8d445d208c284
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON object.
   * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. 
   */
  export type JsonObject = {[Key in string]?: JsonValue}

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON array.
   */
  export interface JsonArray extends Array<JsonValue> {}

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches any valid JSON value.
   */
  export type JsonValue = string | number | boolean | JsonObject | JsonArray | null

  /**
   * Matches a JSON object.
   * Unlike `JsonObject`, this type allows undefined and read-only properties.
   */
  export type InputJsonObject = {readonly [Key in string]?: InputJsonValue | null}

  /**
   * Matches a JSON array.
   * Unlike `JsonArray`, readonly arrays are assignable to this type.
   */
  export interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {}

  /**
   * Matches any valid value that can be used as an input for operations like
   * create and update as the value of a JSON field. Unlike `JsonValue`, this
   * type allows read-only arrays and read-only object properties and disallows
   * `null` at the top level.
   *
   * `null` cannot be used as the value of a JSON field because its meaning
   * would be ambiguous. Use `Prisma.JsonNull` to store the JSON null value or
   * `Prisma.DbNull` to clear the JSON value and set the field to the database
   * NULL value instead.
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
   */
  export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | { toJSON(): unknown }

  /**
   * 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: {
    Ccis: 'Ccis',
    Turnover: 'Turnover',
    NEmployees: 'NEmployees',
    City: 'City',
    Position: 'Position',
    ActivityFamily: 'ActivityFamily',
    Activity: 'Activity',
    ExpertiseArea: 'ExpertiseArea',
    InterestArea: 'InterestArea',
    Province: 'Province',
    Category: 'Category',
    Commission: 'Commission',
    Mandate: 'Mandate',
    College: 'College',
    ElectedMember: 'ElectedMember',
    User: 'User',
    Notification: 'Notification',
    Company: 'Company',
    Connection: 'Connection',
    Message: 'Message',
    Opportunity: 'Opportunity',
    OpportunityLike: 'OpportunityLike',
    OpportunityComment: 'OpportunityComment',
    Event: 'Event',
    EventLike: 'EventLike',
    EventComment: 'EventComment',
    Appointment: 'Appointment',
    AppointmentLike: 'AppointmentLike',
    AppointmentComment: 'AppointmentComment',
    AppointmentRegistration: 'AppointmentRegistration',
    Album: 'Album',
    Video: 'Video',
    Edition: 'Edition',
    Training: 'Training',
    Fair: 'Fair',
    BusinessPlan: 'BusinessPlan',
    MarketResearch: 'MarketResearch',
    Networking: 'Networking',
    Sourcing: 'Sourcing',
    Prospecting: 'Prospecting',
    SmsLog: 'SmsLog'
  };

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


  export type Datasources = {
    db?: Datasource
  }


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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    meta: {
      modelProps: 'ccis' | 'turnover' | 'nEmployees' | 'city' | 'position' | 'activityFamily' | 'activity' | 'expertiseArea' | 'interestArea' | 'province' | 'category' | 'commission' | 'mandate' | 'college' | 'electedMember' | 'user' | 'notification' | 'company' | 'connection' | 'message' | 'opportunity' | 'opportunityLike' | 'opportunityComment' | 'event' | 'eventLike' | 'eventComment' | 'appointment' | 'appointmentLike' | 'appointmentComment' | 'appointmentRegistration' | 'album' | 'video' | 'edition' | 'training' | 'fair' | 'businessPlan' | 'marketResearch' | 'networking' | 'sourcing' | 'prospecting' | 'smsLog'
      txIsolationLevel: Prisma.TransactionIsolationLevel
    },
    model: {
      Ccis: {
        payload: Prisma.$CcisPayload<ExtArgs>
        fields: Prisma.CcisFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CcisFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CcisFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          findFirst: {
            args: Prisma.CcisFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CcisFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          findMany: {
            args: Prisma.CcisFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>[]
          }
          create: {
            args: Prisma.CcisCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          createMany: {
            args: Prisma.CcisCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CcisDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          update: {
            args: Prisma.CcisUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          deleteMany: {
            args: Prisma.CcisDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CcisUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CcisUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CcisPayload>
          }
          aggregate: {
            args: Prisma.CcisAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCcis>
          }
          groupBy: {
            args: Prisma.CcisGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CcisGroupByOutputType>[]
          }
          count: {
            args: Prisma.CcisCountArgs<ExtArgs>,
            result: $Utils.Optional<CcisCountAggregateOutputType> | number
          }
        }
      }
      Turnover: {
        payload: Prisma.$TurnoverPayload<ExtArgs>
        fields: Prisma.TurnoverFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TurnoverFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TurnoverFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          findFirst: {
            args: Prisma.TurnoverFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TurnoverFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          findMany: {
            args: Prisma.TurnoverFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>[]
          }
          create: {
            args: Prisma.TurnoverCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          createMany: {
            args: Prisma.TurnoverCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.TurnoverDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          update: {
            args: Prisma.TurnoverUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          deleteMany: {
            args: Prisma.TurnoverDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.TurnoverUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.TurnoverUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TurnoverPayload>
          }
          aggregate: {
            args: Prisma.TurnoverAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateTurnover>
          }
          groupBy: {
            args: Prisma.TurnoverGroupByArgs<ExtArgs>,
            result: $Utils.Optional<TurnoverGroupByOutputType>[]
          }
          count: {
            args: Prisma.TurnoverCountArgs<ExtArgs>,
            result: $Utils.Optional<TurnoverCountAggregateOutputType> | number
          }
        }
      }
      NEmployees: {
        payload: Prisma.$NEmployeesPayload<ExtArgs>
        fields: Prisma.NEmployeesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NEmployeesFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NEmployeesFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          findFirst: {
            args: Prisma.NEmployeesFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NEmployeesFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          findMany: {
            args: Prisma.NEmployeesFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>[]
          }
          create: {
            args: Prisma.NEmployeesCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          createMany: {
            args: Prisma.NEmployeesCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.NEmployeesDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          update: {
            args: Prisma.NEmployeesUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          deleteMany: {
            args: Prisma.NEmployeesDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.NEmployeesUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.NEmployeesUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NEmployeesPayload>
          }
          aggregate: {
            args: Prisma.NEmployeesAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateNEmployees>
          }
          groupBy: {
            args: Prisma.NEmployeesGroupByArgs<ExtArgs>,
            result: $Utils.Optional<NEmployeesGroupByOutputType>[]
          }
          count: {
            args: Prisma.NEmployeesCountArgs<ExtArgs>,
            result: $Utils.Optional<NEmployeesCountAggregateOutputType> | number
          }
        }
      }
      City: {
        payload: Prisma.$CityPayload<ExtArgs>
        fields: Prisma.CityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CityFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CityFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          findFirst: {
            args: Prisma.CityFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CityFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          findMany: {
            args: Prisma.CityFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>[]
          }
          create: {
            args: Prisma.CityCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          createMany: {
            args: Prisma.CityCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CityDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          update: {
            args: Prisma.CityUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          deleteMany: {
            args: Prisma.CityDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CityUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CityUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          aggregate: {
            args: Prisma.CityAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCity>
          }
          groupBy: {
            args: Prisma.CityGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CityGroupByOutputType>[]
          }
          count: {
            args: Prisma.CityCountArgs<ExtArgs>,
            result: $Utils.Optional<CityCountAggregateOutputType> | number
          }
        }
      }
      Position: {
        payload: Prisma.$PositionPayload<ExtArgs>
        fields: Prisma.PositionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PositionFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PositionFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          findFirst: {
            args: Prisma.PositionFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PositionFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          findMany: {
            args: Prisma.PositionFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>[]
          }
          create: {
            args: Prisma.PositionCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          createMany: {
            args: Prisma.PositionCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.PositionDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          update: {
            args: Prisma.PositionUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          deleteMany: {
            args: Prisma.PositionDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.PositionUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.PositionUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PositionPayload>
          }
          aggregate: {
            args: Prisma.PositionAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregatePosition>
          }
          groupBy: {
            args: Prisma.PositionGroupByArgs<ExtArgs>,
            result: $Utils.Optional<PositionGroupByOutputType>[]
          }
          count: {
            args: Prisma.PositionCountArgs<ExtArgs>,
            result: $Utils.Optional<PositionCountAggregateOutputType> | number
          }
        }
      }
      ActivityFamily: {
        payload: Prisma.$ActivityFamilyPayload<ExtArgs>
        fields: Prisma.ActivityFamilyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ActivityFamilyFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ActivityFamilyFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          findFirst: {
            args: Prisma.ActivityFamilyFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ActivityFamilyFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          findMany: {
            args: Prisma.ActivityFamilyFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>[]
          }
          create: {
            args: Prisma.ActivityFamilyCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          createMany: {
            args: Prisma.ActivityFamilyCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ActivityFamilyDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          update: {
            args: Prisma.ActivityFamilyUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          deleteMany: {
            args: Prisma.ActivityFamilyDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ActivityFamilyUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ActivityFamilyUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityFamilyPayload>
          }
          aggregate: {
            args: Prisma.ActivityFamilyAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateActivityFamily>
          }
          groupBy: {
            args: Prisma.ActivityFamilyGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ActivityFamilyGroupByOutputType>[]
          }
          count: {
            args: Prisma.ActivityFamilyCountArgs<ExtArgs>,
            result: $Utils.Optional<ActivityFamilyCountAggregateOutputType> | number
          }
        }
      }
      Activity: {
        payload: Prisma.$ActivityPayload<ExtArgs>
        fields: Prisma.ActivityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ActivityFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ActivityFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          findFirst: {
            args: Prisma.ActivityFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ActivityFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          findMany: {
            args: Prisma.ActivityFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>[]
          }
          create: {
            args: Prisma.ActivityCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          createMany: {
            args: Prisma.ActivityCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ActivityDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          update: {
            args: Prisma.ActivityUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          deleteMany: {
            args: Prisma.ActivityDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ActivityUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ActivityUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ActivityPayload>
          }
          aggregate: {
            args: Prisma.ActivityAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateActivity>
          }
          groupBy: {
            args: Prisma.ActivityGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ActivityGroupByOutputType>[]
          }
          count: {
            args: Prisma.ActivityCountArgs<ExtArgs>,
            result: $Utils.Optional<ActivityCountAggregateOutputType> | number
          }
        }
      }
      ExpertiseArea: {
        payload: Prisma.$ExpertiseAreaPayload<ExtArgs>
        fields: Prisma.ExpertiseAreaFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExpertiseAreaFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExpertiseAreaFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          findFirst: {
            args: Prisma.ExpertiseAreaFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExpertiseAreaFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          findMany: {
            args: Prisma.ExpertiseAreaFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>[]
          }
          create: {
            args: Prisma.ExpertiseAreaCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          createMany: {
            args: Prisma.ExpertiseAreaCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ExpertiseAreaDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          update: {
            args: Prisma.ExpertiseAreaUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          deleteMany: {
            args: Prisma.ExpertiseAreaDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ExpertiseAreaUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ExpertiseAreaUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ExpertiseAreaPayload>
          }
          aggregate: {
            args: Prisma.ExpertiseAreaAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateExpertiseArea>
          }
          groupBy: {
            args: Prisma.ExpertiseAreaGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ExpertiseAreaGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExpertiseAreaCountArgs<ExtArgs>,
            result: $Utils.Optional<ExpertiseAreaCountAggregateOutputType> | number
          }
        }
      }
      InterestArea: {
        payload: Prisma.$InterestAreaPayload<ExtArgs>
        fields: Prisma.InterestAreaFieldRefs
        operations: {
          findUnique: {
            args: Prisma.InterestAreaFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.InterestAreaFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          findFirst: {
            args: Prisma.InterestAreaFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.InterestAreaFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          findMany: {
            args: Prisma.InterestAreaFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>[]
          }
          create: {
            args: Prisma.InterestAreaCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          createMany: {
            args: Prisma.InterestAreaCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.InterestAreaDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          update: {
            args: Prisma.InterestAreaUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          deleteMany: {
            args: Prisma.InterestAreaDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.InterestAreaUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.InterestAreaUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$InterestAreaPayload>
          }
          aggregate: {
            args: Prisma.InterestAreaAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateInterestArea>
          }
          groupBy: {
            args: Prisma.InterestAreaGroupByArgs<ExtArgs>,
            result: $Utils.Optional<InterestAreaGroupByOutputType>[]
          }
          count: {
            args: Prisma.InterestAreaCountArgs<ExtArgs>,
            result: $Utils.Optional<InterestAreaCountAggregateOutputType> | number
          }
        }
      }
      Province: {
        payload: Prisma.$ProvincePayload<ExtArgs>
        fields: Prisma.ProvinceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProvinceFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProvinceFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          findFirst: {
            args: Prisma.ProvinceFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProvinceFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          findMany: {
            args: Prisma.ProvinceFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>[]
          }
          create: {
            args: Prisma.ProvinceCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          createMany: {
            args: Prisma.ProvinceCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ProvinceDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          update: {
            args: Prisma.ProvinceUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          deleteMany: {
            args: Prisma.ProvinceDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ProvinceUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ProvinceUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProvincePayload>
          }
          aggregate: {
            args: Prisma.ProvinceAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateProvince>
          }
          groupBy: {
            args: Prisma.ProvinceGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ProvinceGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProvinceCountArgs<ExtArgs>,
            result: $Utils.Optional<ProvinceCountAggregateOutputType> | number
          }
        }
      }
      Category: {
        payload: Prisma.$CategoryPayload<ExtArgs>
        fields: Prisma.CategoryFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CategoryFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CategoryFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          findFirst: {
            args: Prisma.CategoryFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CategoryFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          findMany: {
            args: Prisma.CategoryFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
          }
          create: {
            args: Prisma.CategoryCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          createMany: {
            args: Prisma.CategoryCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CategoryDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          update: {
            args: Prisma.CategoryUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          deleteMany: {
            args: Prisma.CategoryDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CategoryUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CategoryUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          aggregate: {
            args: Prisma.CategoryAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCategory>
          }
          groupBy: {
            args: Prisma.CategoryGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CategoryGroupByOutputType>[]
          }
          count: {
            args: Prisma.CategoryCountArgs<ExtArgs>,
            result: $Utils.Optional<CategoryCountAggregateOutputType> | number
          }
        }
      }
      Commission: {
        payload: Prisma.$CommissionPayload<ExtArgs>
        fields: Prisma.CommissionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommissionFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommissionFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          findFirst: {
            args: Prisma.CommissionFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommissionFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          findMany: {
            args: Prisma.CommissionFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>[]
          }
          create: {
            args: Prisma.CommissionCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          createMany: {
            args: Prisma.CommissionCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CommissionDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          update: {
            args: Prisma.CommissionUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          deleteMany: {
            args: Prisma.CommissionDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CommissionUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CommissionUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CommissionPayload>
          }
          aggregate: {
            args: Prisma.CommissionAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCommission>
          }
          groupBy: {
            args: Prisma.CommissionGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CommissionGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommissionCountArgs<ExtArgs>,
            result: $Utils.Optional<CommissionCountAggregateOutputType> | number
          }
        }
      }
      Mandate: {
        payload: Prisma.$MandatePayload<ExtArgs>
        fields: Prisma.MandateFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MandateFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MandateFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          findFirst: {
            args: Prisma.MandateFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MandateFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          findMany: {
            args: Prisma.MandateFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>[]
          }
          create: {
            args: Prisma.MandateCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          createMany: {
            args: Prisma.MandateCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MandateDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          update: {
            args: Prisma.MandateUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          deleteMany: {
            args: Prisma.MandateDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MandateUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MandateUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MandatePayload>
          }
          aggregate: {
            args: Prisma.MandateAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMandate>
          }
          groupBy: {
            args: Prisma.MandateGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MandateGroupByOutputType>[]
          }
          count: {
            args: Prisma.MandateCountArgs<ExtArgs>,
            result: $Utils.Optional<MandateCountAggregateOutputType> | number
          }
        }
      }
      College: {
        payload: Prisma.$CollegePayload<ExtArgs>
        fields: Prisma.CollegeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CollegeFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CollegeFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          findFirst: {
            args: Prisma.CollegeFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CollegeFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          findMany: {
            args: Prisma.CollegeFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>[]
          }
          create: {
            args: Prisma.CollegeCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          createMany: {
            args: Prisma.CollegeCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CollegeDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          update: {
            args: Prisma.CollegeUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          deleteMany: {
            args: Prisma.CollegeDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CollegeUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CollegeUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CollegePayload>
          }
          aggregate: {
            args: Prisma.CollegeAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCollege>
          }
          groupBy: {
            args: Prisma.CollegeGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CollegeGroupByOutputType>[]
          }
          count: {
            args: Prisma.CollegeCountArgs<ExtArgs>,
            result: $Utils.Optional<CollegeCountAggregateOutputType> | number
          }
        }
      }
      ElectedMember: {
        payload: Prisma.$ElectedMemberPayload<ExtArgs>
        fields: Prisma.ElectedMemberFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ElectedMemberFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ElectedMemberFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          findFirst: {
            args: Prisma.ElectedMemberFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ElectedMemberFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          findMany: {
            args: Prisma.ElectedMemberFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>[]
          }
          create: {
            args: Prisma.ElectedMemberCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          createMany: {
            args: Prisma.ElectedMemberCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ElectedMemberDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          update: {
            args: Prisma.ElectedMemberUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          deleteMany: {
            args: Prisma.ElectedMemberDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ElectedMemberUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ElectedMemberUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ElectedMemberPayload>
          }
          aggregate: {
            args: Prisma.ElectedMemberAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateElectedMember>
          }
          groupBy: {
            args: Prisma.ElectedMemberGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ElectedMemberGroupByOutputType>[]
          }
          count: {
            args: Prisma.ElectedMemberCountArgs<ExtArgs>,
            result: $Utils.Optional<ElectedMemberCountAggregateOutputType> | number
          }
        }
      }
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          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: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>,
            result: Prisma.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
          }
        }
      }
      Notification: {
        payload: Prisma.$NotificationPayload<ExtArgs>
        fields: Prisma.NotificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NotificationFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NotificationFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findFirst: {
            args: Prisma.NotificationFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NotificationFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findMany: {
            args: Prisma.NotificationFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          create: {
            args: Prisma.NotificationCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          createMany: {
            args: Prisma.NotificationCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.NotificationDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          update: {
            args: Prisma.NotificationUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          deleteMany: {
            args: Prisma.NotificationDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.NotificationUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.NotificationUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          aggregate: {
            args: Prisma.NotificationAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateNotification>
          }
          groupBy: {
            args: Prisma.NotificationGroupByArgs<ExtArgs>,
            result: $Utils.Optional<NotificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.NotificationCountArgs<ExtArgs>,
            result: $Utils.Optional<NotificationCountAggregateOutputType> | number
          }
        }
      }
      Company: {
        payload: Prisma.$CompanyPayload<ExtArgs>
        fields: Prisma.CompanyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CompanyFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CompanyFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          findFirst: {
            args: Prisma.CompanyFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CompanyFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          findMany: {
            args: Prisma.CompanyFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>[]
          }
          create: {
            args: Prisma.CompanyCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          createMany: {
            args: Prisma.CompanyCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CompanyDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          update: {
            args: Prisma.CompanyUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          deleteMany: {
            args: Prisma.CompanyDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CompanyUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CompanyUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CompanyPayload>
          }
          aggregate: {
            args: Prisma.CompanyAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCompany>
          }
          groupBy: {
            args: Prisma.CompanyGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CompanyGroupByOutputType>[]
          }
          count: {
            args: Prisma.CompanyCountArgs<ExtArgs>,
            result: $Utils.Optional<CompanyCountAggregateOutputType> | number
          }
        }
      }
      Connection: {
        payload: Prisma.$ConnectionPayload<ExtArgs>
        fields: Prisma.ConnectionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ConnectionFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ConnectionFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          findFirst: {
            args: Prisma.ConnectionFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ConnectionFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          findMany: {
            args: Prisma.ConnectionFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>[]
          }
          create: {
            args: Prisma.ConnectionCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          createMany: {
            args: Prisma.ConnectionCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ConnectionDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          update: {
            args: Prisma.ConnectionUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          deleteMany: {
            args: Prisma.ConnectionDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ConnectionUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ConnectionUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ConnectionPayload>
          }
          aggregate: {
            args: Prisma.ConnectionAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateConnection>
          }
          groupBy: {
            args: Prisma.ConnectionGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ConnectionGroupByOutputType>[]
          }
          count: {
            args: Prisma.ConnectionCountArgs<ExtArgs>,
            result: $Utils.Optional<ConnectionCountAggregateOutputType> | number
          }
        }
      }
      Message: {
        payload: Prisma.$MessagePayload<ExtArgs>
        fields: Prisma.MessageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MessageFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MessageFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          findFirst: {
            args: Prisma.MessageFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MessageFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          findMany: {
            args: Prisma.MessageFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>[]
          }
          create: {
            args: Prisma.MessageCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          createMany: {
            args: Prisma.MessageCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MessageDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          update: {
            args: Prisma.MessageUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          deleteMany: {
            args: Prisma.MessageDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MessageUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MessageUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagePayload>
          }
          aggregate: {
            args: Prisma.MessageAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMessage>
          }
          groupBy: {
            args: Prisma.MessageGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MessageGroupByOutputType>[]
          }
          count: {
            args: Prisma.MessageCountArgs<ExtArgs>,
            result: $Utils.Optional<MessageCountAggregateOutputType> | number
          }
        }
      }
      Opportunity: {
        payload: Prisma.$OpportunityPayload<ExtArgs>
        fields: Prisma.OpportunityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OpportunityFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OpportunityFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          findFirst: {
            args: Prisma.OpportunityFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OpportunityFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          findMany: {
            args: Prisma.OpportunityFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>[]
          }
          create: {
            args: Prisma.OpportunityCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          createMany: {
            args: Prisma.OpportunityCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.OpportunityDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          update: {
            args: Prisma.OpportunityUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          deleteMany: {
            args: Prisma.OpportunityDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.OpportunityUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.OpportunityUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityPayload>
          }
          aggregate: {
            args: Prisma.OpportunityAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateOpportunity>
          }
          groupBy: {
            args: Prisma.OpportunityGroupByArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityGroupByOutputType>[]
          }
          count: {
            args: Prisma.OpportunityCountArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityCountAggregateOutputType> | number
          }
        }
      }
      OpportunityLike: {
        payload: Prisma.$OpportunityLikePayload<ExtArgs>
        fields: Prisma.OpportunityLikeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OpportunityLikeFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OpportunityLikeFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          findFirst: {
            args: Prisma.OpportunityLikeFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OpportunityLikeFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          findMany: {
            args: Prisma.OpportunityLikeFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>[]
          }
          create: {
            args: Prisma.OpportunityLikeCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          createMany: {
            args: Prisma.OpportunityLikeCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.OpportunityLikeDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          update: {
            args: Prisma.OpportunityLikeUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          deleteMany: {
            args: Prisma.OpportunityLikeDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.OpportunityLikeUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.OpportunityLikeUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityLikePayload>
          }
          aggregate: {
            args: Prisma.OpportunityLikeAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateOpportunityLike>
          }
          groupBy: {
            args: Prisma.OpportunityLikeGroupByArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityLikeGroupByOutputType>[]
          }
          count: {
            args: Prisma.OpportunityLikeCountArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityLikeCountAggregateOutputType> | number
          }
        }
      }
      OpportunityComment: {
        payload: Prisma.$OpportunityCommentPayload<ExtArgs>
        fields: Prisma.OpportunityCommentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OpportunityCommentFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OpportunityCommentFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          findFirst: {
            args: Prisma.OpportunityCommentFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OpportunityCommentFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          findMany: {
            args: Prisma.OpportunityCommentFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>[]
          }
          create: {
            args: Prisma.OpportunityCommentCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          createMany: {
            args: Prisma.OpportunityCommentCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.OpportunityCommentDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          update: {
            args: Prisma.OpportunityCommentUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          deleteMany: {
            args: Prisma.OpportunityCommentDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.OpportunityCommentUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.OpportunityCommentUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OpportunityCommentPayload>
          }
          aggregate: {
            args: Prisma.OpportunityCommentAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateOpportunityComment>
          }
          groupBy: {
            args: Prisma.OpportunityCommentGroupByArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityCommentGroupByOutputType>[]
          }
          count: {
            args: Prisma.OpportunityCommentCountArgs<ExtArgs>,
            result: $Utils.Optional<OpportunityCommentCountAggregateOutputType> | 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: Prisma.BatchPayload
          }
          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: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.EventUpdateManyArgs<ExtArgs>,
            result: Prisma.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
          }
        }
      }
      EventLike: {
        payload: Prisma.$EventLikePayload<ExtArgs>
        fields: Prisma.EventLikeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EventLikeFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EventLikeFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          findFirst: {
            args: Prisma.EventLikeFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EventLikeFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          findMany: {
            args: Prisma.EventLikeFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>[]
          }
          create: {
            args: Prisma.EventLikeCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          createMany: {
            args: Prisma.EventLikeCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.EventLikeDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          update: {
            args: Prisma.EventLikeUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          deleteMany: {
            args: Prisma.EventLikeDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.EventLikeUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.EventLikeUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventLikePayload>
          }
          aggregate: {
            args: Prisma.EventLikeAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateEventLike>
          }
          groupBy: {
            args: Prisma.EventLikeGroupByArgs<ExtArgs>,
            result: $Utils.Optional<EventLikeGroupByOutputType>[]
          }
          count: {
            args: Prisma.EventLikeCountArgs<ExtArgs>,
            result: $Utils.Optional<EventLikeCountAggregateOutputType> | number
          }
        }
      }
      EventComment: {
        payload: Prisma.$EventCommentPayload<ExtArgs>
        fields: Prisma.EventCommentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EventCommentFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EventCommentFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          findFirst: {
            args: Prisma.EventCommentFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EventCommentFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          findMany: {
            args: Prisma.EventCommentFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>[]
          }
          create: {
            args: Prisma.EventCommentCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          createMany: {
            args: Prisma.EventCommentCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.EventCommentDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          update: {
            args: Prisma.EventCommentUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          deleteMany: {
            args: Prisma.EventCommentDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.EventCommentUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.EventCommentUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EventCommentPayload>
          }
          aggregate: {
            args: Prisma.EventCommentAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateEventComment>
          }
          groupBy: {
            args: Prisma.EventCommentGroupByArgs<ExtArgs>,
            result: $Utils.Optional<EventCommentGroupByOutputType>[]
          }
          count: {
            args: Prisma.EventCommentCountArgs<ExtArgs>,
            result: $Utils.Optional<EventCommentCountAggregateOutputType> | number
          }
        }
      }
      Appointment: {
        payload: Prisma.$AppointmentPayload<ExtArgs>
        fields: Prisma.AppointmentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          findFirst: {
            args: Prisma.AppointmentFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          findMany: {
            args: Prisma.AppointmentFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>[]
          }
          create: {
            args: Prisma.AppointmentCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          createMany: {
            args: Prisma.AppointmentCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AppointmentDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          update: {
            args: Prisma.AppointmentUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          deleteMany: {
            args: Prisma.AppointmentDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AppointmentUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          aggregate: {
            args: Prisma.AppointmentAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAppointment>
          }
          groupBy: {
            args: Prisma.AppointmentGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentCountArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentCountAggregateOutputType> | number
          }
        }
      }
      AppointmentLike: {
        payload: Prisma.$AppointmentLikePayload<ExtArgs>
        fields: Prisma.AppointmentLikeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentLikeFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentLikeFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          findFirst: {
            args: Prisma.AppointmentLikeFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentLikeFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          findMany: {
            args: Prisma.AppointmentLikeFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>[]
          }
          create: {
            args: Prisma.AppointmentLikeCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          createMany: {
            args: Prisma.AppointmentLikeCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AppointmentLikeDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          update: {
            args: Prisma.AppointmentLikeUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          deleteMany: {
            args: Prisma.AppointmentLikeDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentLikeUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AppointmentLikeUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentLikePayload>
          }
          aggregate: {
            args: Prisma.AppointmentLikeAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAppointmentLike>
          }
          groupBy: {
            args: Prisma.AppointmentLikeGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentLikeGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentLikeCountArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentLikeCountAggregateOutputType> | number
          }
        }
      }
      AppointmentComment: {
        payload: Prisma.$AppointmentCommentPayload<ExtArgs>
        fields: Prisma.AppointmentCommentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentCommentFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentCommentFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          findFirst: {
            args: Prisma.AppointmentCommentFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentCommentFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          findMany: {
            args: Prisma.AppointmentCommentFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>[]
          }
          create: {
            args: Prisma.AppointmentCommentCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          createMany: {
            args: Prisma.AppointmentCommentCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AppointmentCommentDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          update: {
            args: Prisma.AppointmentCommentUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          deleteMany: {
            args: Prisma.AppointmentCommentDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentCommentUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AppointmentCommentUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentCommentPayload>
          }
          aggregate: {
            args: Prisma.AppointmentCommentAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAppointmentComment>
          }
          groupBy: {
            args: Prisma.AppointmentCommentGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentCommentGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentCommentCountArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentCommentCountAggregateOutputType> | number
          }
        }
      }
      AppointmentRegistration: {
        payload: Prisma.$AppointmentRegistrationPayload<ExtArgs>
        fields: Prisma.AppointmentRegistrationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentRegistrationFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentRegistrationFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          findFirst: {
            args: Prisma.AppointmentRegistrationFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentRegistrationFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          findMany: {
            args: Prisma.AppointmentRegistrationFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>[]
          }
          create: {
            args: Prisma.AppointmentRegistrationCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          createMany: {
            args: Prisma.AppointmentRegistrationCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AppointmentRegistrationDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          update: {
            args: Prisma.AppointmentRegistrationUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          deleteMany: {
            args: Prisma.AppointmentRegistrationDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentRegistrationUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AppointmentRegistrationUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AppointmentRegistrationPayload>
          }
          aggregate: {
            args: Prisma.AppointmentRegistrationAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAppointmentRegistration>
          }
          groupBy: {
            args: Prisma.AppointmentRegistrationGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentRegistrationGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentRegistrationCountArgs<ExtArgs>,
            result: $Utils.Optional<AppointmentRegistrationCountAggregateOutputType> | number
          }
        }
      }
      Album: {
        payload: Prisma.$AlbumPayload<ExtArgs>
        fields: Prisma.AlbumFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AlbumFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AlbumFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          findFirst: {
            args: Prisma.AlbumFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AlbumFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          findMany: {
            args: Prisma.AlbumFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>[]
          }
          create: {
            args: Prisma.AlbumCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          createMany: {
            args: Prisma.AlbumCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AlbumDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          update: {
            args: Prisma.AlbumUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          deleteMany: {
            args: Prisma.AlbumDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AlbumUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AlbumUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AlbumPayload>
          }
          aggregate: {
            args: Prisma.AlbumAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAlbum>
          }
          groupBy: {
            args: Prisma.AlbumGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AlbumGroupByOutputType>[]
          }
          count: {
            args: Prisma.AlbumCountArgs<ExtArgs>,
            result: $Utils.Optional<AlbumCountAggregateOutputType> | number
          }
        }
      }
      Video: {
        payload: Prisma.$VideoPayload<ExtArgs>
        fields: Prisma.VideoFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VideoFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VideoFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          findFirst: {
            args: Prisma.VideoFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VideoFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          findMany: {
            args: Prisma.VideoFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>[]
          }
          create: {
            args: Prisma.VideoCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          createMany: {
            args: Prisma.VideoCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.VideoDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          update: {
            args: Prisma.VideoUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          deleteMany: {
            args: Prisma.VideoDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.VideoUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.VideoUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          aggregate: {
            args: Prisma.VideoAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateVideo>
          }
          groupBy: {
            args: Prisma.VideoGroupByArgs<ExtArgs>,
            result: $Utils.Optional<VideoGroupByOutputType>[]
          }
          count: {
            args: Prisma.VideoCountArgs<ExtArgs>,
            result: $Utils.Optional<VideoCountAggregateOutputType> | number
          }
        }
      }
      Edition: {
        payload: Prisma.$EditionPayload<ExtArgs>
        fields: Prisma.EditionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EditionFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EditionFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          findFirst: {
            args: Prisma.EditionFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EditionFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          findMany: {
            args: Prisma.EditionFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>[]
          }
          create: {
            args: Prisma.EditionCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          createMany: {
            args: Prisma.EditionCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.EditionDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          update: {
            args: Prisma.EditionUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          deleteMany: {
            args: Prisma.EditionDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.EditionUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.EditionUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EditionPayload>
          }
          aggregate: {
            args: Prisma.EditionAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateEdition>
          }
          groupBy: {
            args: Prisma.EditionGroupByArgs<ExtArgs>,
            result: $Utils.Optional<EditionGroupByOutputType>[]
          }
          count: {
            args: Prisma.EditionCountArgs<ExtArgs>,
            result: $Utils.Optional<EditionCountAggregateOutputType> | number
          }
        }
      }
      Training: {
        payload: Prisma.$TrainingPayload<ExtArgs>
        fields: Prisma.TrainingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TrainingFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TrainingFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          findFirst: {
            args: Prisma.TrainingFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TrainingFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          findMany: {
            args: Prisma.TrainingFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>[]
          }
          create: {
            args: Prisma.TrainingCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          createMany: {
            args: Prisma.TrainingCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.TrainingDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          update: {
            args: Prisma.TrainingUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          deleteMany: {
            args: Prisma.TrainingDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.TrainingUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.TrainingUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$TrainingPayload>
          }
          aggregate: {
            args: Prisma.TrainingAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateTraining>
          }
          groupBy: {
            args: Prisma.TrainingGroupByArgs<ExtArgs>,
            result: $Utils.Optional<TrainingGroupByOutputType>[]
          }
          count: {
            args: Prisma.TrainingCountArgs<ExtArgs>,
            result: $Utils.Optional<TrainingCountAggregateOutputType> | number
          }
        }
      }
      Fair: {
        payload: Prisma.$FairPayload<ExtArgs>
        fields: Prisma.FairFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FairFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FairFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          findFirst: {
            args: Prisma.FairFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FairFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          findMany: {
            args: Prisma.FairFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>[]
          }
          create: {
            args: Prisma.FairCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          createMany: {
            args: Prisma.FairCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.FairDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          update: {
            args: Prisma.FairUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          deleteMany: {
            args: Prisma.FairDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.FairUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.FairUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FairPayload>
          }
          aggregate: {
            args: Prisma.FairAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateFair>
          }
          groupBy: {
            args: Prisma.FairGroupByArgs<ExtArgs>,
            result: $Utils.Optional<FairGroupByOutputType>[]
          }
          count: {
            args: Prisma.FairCountArgs<ExtArgs>,
            result: $Utils.Optional<FairCountAggregateOutputType> | number
          }
        }
      }
      BusinessPlan: {
        payload: Prisma.$BusinessPlanPayload<ExtArgs>
        fields: Prisma.BusinessPlanFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BusinessPlanFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BusinessPlanFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          findFirst: {
            args: Prisma.BusinessPlanFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BusinessPlanFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          findMany: {
            args: Prisma.BusinessPlanFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>[]
          }
          create: {
            args: Prisma.BusinessPlanCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          createMany: {
            args: Prisma.BusinessPlanCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.BusinessPlanDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          update: {
            args: Prisma.BusinessPlanUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          deleteMany: {
            args: Prisma.BusinessPlanDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.BusinessPlanUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.BusinessPlanUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BusinessPlanPayload>
          }
          aggregate: {
            args: Prisma.BusinessPlanAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateBusinessPlan>
          }
          groupBy: {
            args: Prisma.BusinessPlanGroupByArgs<ExtArgs>,
            result: $Utils.Optional<BusinessPlanGroupByOutputType>[]
          }
          count: {
            args: Prisma.BusinessPlanCountArgs<ExtArgs>,
            result: $Utils.Optional<BusinessPlanCountAggregateOutputType> | number
          }
        }
      }
      MarketResearch: {
        payload: Prisma.$MarketResearchPayload<ExtArgs>
        fields: Prisma.MarketResearchFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MarketResearchFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MarketResearchFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          findFirst: {
            args: Prisma.MarketResearchFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MarketResearchFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          findMany: {
            args: Prisma.MarketResearchFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>[]
          }
          create: {
            args: Prisma.MarketResearchCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          createMany: {
            args: Prisma.MarketResearchCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MarketResearchDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          update: {
            args: Prisma.MarketResearchUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          deleteMany: {
            args: Prisma.MarketResearchDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MarketResearchUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MarketResearchUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MarketResearchPayload>
          }
          aggregate: {
            args: Prisma.MarketResearchAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMarketResearch>
          }
          groupBy: {
            args: Prisma.MarketResearchGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MarketResearchGroupByOutputType>[]
          }
          count: {
            args: Prisma.MarketResearchCountArgs<ExtArgs>,
            result: $Utils.Optional<MarketResearchCountAggregateOutputType> | number
          }
        }
      }
      Networking: {
        payload: Prisma.$NetworkingPayload<ExtArgs>
        fields: Prisma.NetworkingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NetworkingFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NetworkingFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          findFirst: {
            args: Prisma.NetworkingFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NetworkingFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          findMany: {
            args: Prisma.NetworkingFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>[]
          }
          create: {
            args: Prisma.NetworkingCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          createMany: {
            args: Prisma.NetworkingCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.NetworkingDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          update: {
            args: Prisma.NetworkingUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          deleteMany: {
            args: Prisma.NetworkingDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.NetworkingUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.NetworkingUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$NetworkingPayload>
          }
          aggregate: {
            args: Prisma.NetworkingAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateNetworking>
          }
          groupBy: {
            args: Prisma.NetworkingGroupByArgs<ExtArgs>,
            result: $Utils.Optional<NetworkingGroupByOutputType>[]
          }
          count: {
            args: Prisma.NetworkingCountArgs<ExtArgs>,
            result: $Utils.Optional<NetworkingCountAggregateOutputType> | number
          }
        }
      }
      Sourcing: {
        payload: Prisma.$SourcingPayload<ExtArgs>
        fields: Prisma.SourcingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SourcingFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SourcingFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          findFirst: {
            args: Prisma.SourcingFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SourcingFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          findMany: {
            args: Prisma.SourcingFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>[]
          }
          create: {
            args: Prisma.SourcingCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          createMany: {
            args: Prisma.SourcingCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SourcingDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          update: {
            args: Prisma.SourcingUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          deleteMany: {
            args: Prisma.SourcingDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SourcingUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SourcingUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SourcingPayload>
          }
          aggregate: {
            args: Prisma.SourcingAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSourcing>
          }
          groupBy: {
            args: Prisma.SourcingGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SourcingGroupByOutputType>[]
          }
          count: {
            args: Prisma.SourcingCountArgs<ExtArgs>,
            result: $Utils.Optional<SourcingCountAggregateOutputType> | number
          }
        }
      }
      Prospecting: {
        payload: Prisma.$ProspectingPayload<ExtArgs>
        fields: Prisma.ProspectingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProspectingFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProspectingFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          findFirst: {
            args: Prisma.ProspectingFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProspectingFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          findMany: {
            args: Prisma.ProspectingFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>[]
          }
          create: {
            args: Prisma.ProspectingCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          createMany: {
            args: Prisma.ProspectingCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ProspectingDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          update: {
            args: Prisma.ProspectingUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          deleteMany: {
            args: Prisma.ProspectingDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ProspectingUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ProspectingUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ProspectingPayload>
          }
          aggregate: {
            args: Prisma.ProspectingAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateProspecting>
          }
          groupBy: {
            args: Prisma.ProspectingGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ProspectingGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProspectingCountArgs<ExtArgs>,
            result: $Utils.Optional<ProspectingCountAggregateOutputType> | number
          }
        }
      }
      SmsLog: {
        payload: Prisma.$SmsLogPayload<ExtArgs>
        fields: Prisma.SmsLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SmsLogFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SmsLogFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          findFirst: {
            args: Prisma.SmsLogFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SmsLogFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          findMany: {
            args: Prisma.SmsLogFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>[]
          }
          create: {
            args: Prisma.SmsLogCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          createMany: {
            args: Prisma.SmsLogCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SmsLogDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          update: {
            args: Prisma.SmsLogUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          deleteMany: {
            args: Prisma.SmsLogDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SmsLogUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SmsLogUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
          }
          aggregate: {
            args: Prisma.SmsLogAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSmsLog>
          }
          groupBy: {
            args: Prisma.SmsLogGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SmsLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.SmsLogCountArgs<ExtArgs>,
            result: $Utils.Optional<SmsLogCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...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'
    | '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 TurnoverCountOutputType
   */

  export type TurnoverCountOutputType = {
    companies: number
  }

  export type TurnoverCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    companies?: boolean | TurnoverCountOutputTypeCountCompaniesArgs
  }

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

  /**
   * TurnoverCountOutputType without action
   */
  export type TurnoverCountOutputTypeCountCompaniesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CompanyWhereInput
  }


  /**
   * Count Type NEmployeesCountOutputType
   */

  export type NEmployeesCountOutputType = {
    companies: number
  }

  export type NEmployeesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    companies?: boolean | NEmployeesCountOutputTypeCountCompaniesArgs
  }

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

  /**
   * NEmployeesCountOutputType without action
   */
  export type NEmployeesCountOutputTypeCountCompaniesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CompanyWhereInput
  }


  /**
   * Count Type CityCountOutputType
   */

  export type CityCountOutputType = {
    users: number
    companies: number
  }

  export type CityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | CityCountOutputTypeCountUsersArgs
    companies?: boolean | CityCountOutputTypeCountCompaniesArgs
  }

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

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

  /**
   * CityCountOutputType without action
   */
  export type CityCountOutputTypeCountCompaniesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CompanyWhereInput
  }


  /**
   * Count Type PositionCountOutputType
   */

  export type PositionCountOutputType = {
    users: number
    companies: number
    electedMembers: number
  }

  export type PositionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | PositionCountOutputTypeCountUsersArgs
    companies?: boolean | PositionCountOutputTypeCountCompaniesArgs
    electedMembers?: boolean | PositionCountOutputTypeCountElectedMembersArgs
  }

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

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

  /**
   * PositionCountOutputType without action
   */
  export type PositionCountOutputTypeCountCompaniesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CompanyWhereInput
  }

  /**
   * PositionCountOutputType without action
   */
  export type PositionCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }


  /**
   * Count Type ActivityFamilyCountOutputType
   */

  export type ActivityFamilyCountOutputType = {
    activities: number
    electedMembers: number
  }

  export type ActivityFamilyCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | ActivityFamilyCountOutputTypeCountActivitiesArgs
    electedMembers?: boolean | ActivityFamilyCountOutputTypeCountElectedMembersArgs
  }

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

  /**
   * ActivityFamilyCountOutputType without action
   */
  export type ActivityFamilyCountOutputTypeCountActivitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ActivityWhereInput
  }

  /**
   * ActivityFamilyCountOutputType without action
   */
  export type ActivityFamilyCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }


  /**
   * Count Type ActivityCountOutputType
   */

  export type ActivityCountOutputType = {
    electedMembers: number
  }

  export type ActivityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | ActivityCountOutputTypeCountElectedMembersArgs
  }

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

  /**
   * ActivityCountOutputType without action
   */
  export type ActivityCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }


  /**
   * Count Type ProvinceCountOutputType
   */

  export type ProvinceCountOutputType = {
    electedMembers: number
    user: number
  }

  export type ProvinceCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | ProvinceCountOutputTypeCountElectedMembersArgs
    user?: boolean | ProvinceCountOutputTypeCountUserArgs
  }

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

  /**
   * ProvinceCountOutputType without action
   */
  export type ProvinceCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }

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


  /**
   * Count Type CategoryCountOutputType
   */

  export type CategoryCountOutputType = {
    editions: number
  }

  export type CategoryCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    editions?: boolean | CategoryCountOutputTypeCountEditionsArgs
  }

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

  /**
   * CategoryCountOutputType without action
   */
  export type CategoryCountOutputTypeCountEditionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EditionWhereInput
  }


  /**
   * Count Type MandateCountOutputType
   */

  export type MandateCountOutputType = {
    electedMembers: number
    user: number
  }

  export type MandateCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | MandateCountOutputTypeCountElectedMembersArgs
    user?: boolean | MandateCountOutputTypeCountUserArgs
  }

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

  /**
   * MandateCountOutputType without action
   */
  export type MandateCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }

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


  /**
   * Count Type CollegeCountOutputType
   */

  export type CollegeCountOutputType = {
    electedMembers: number
    user: number
  }

  export type CollegeCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | CollegeCountOutputTypeCountElectedMembersArgs
    user?: boolean | CollegeCountOutputTypeCountUserArgs
  }

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

  /**
   * CollegeCountOutputType without action
   */
  export type CollegeCountOutputTypeCountElectedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
  }

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


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    connectionsSent: number
    connectionsReceived: number
    messagesSent: number
    messagesReceived: number
    opportunities: number
    opportunityLikes: number
    opportunityComments: number
    eventLikes: number
    eventComments: number
    appointmentLikes: number
    appointmentComments: number
    notifications: number
    appointmentsRegistrations: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    connectionsSent?: boolean | UserCountOutputTypeCountConnectionsSentArgs
    connectionsReceived?: boolean | UserCountOutputTypeCountConnectionsReceivedArgs
    messagesSent?: boolean | UserCountOutputTypeCountMessagesSentArgs
    messagesReceived?: boolean | UserCountOutputTypeCountMessagesReceivedArgs
    opportunities?: boolean | UserCountOutputTypeCountOpportunitiesArgs
    opportunityLikes?: boolean | UserCountOutputTypeCountOpportunityLikesArgs
    opportunityComments?: boolean | UserCountOutputTypeCountOpportunityCommentsArgs
    eventLikes?: boolean | UserCountOutputTypeCountEventLikesArgs
    eventComments?: boolean | UserCountOutputTypeCountEventCommentsArgs
    appointmentLikes?: boolean | UserCountOutputTypeCountAppointmentLikesArgs
    appointmentComments?: boolean | UserCountOutputTypeCountAppointmentCommentsArgs
    notifications?: boolean | UserCountOutputTypeCountNotificationsArgs
    appointmentsRegistrations?: boolean | UserCountOutputTypeCountAppointmentsRegistrationsArgs
  }

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

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

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

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

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

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

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

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

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

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

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

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

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


  /**
   * Count Type CompanyCountOutputType
   */

  export type CompanyCountOutputType = {
    users: number
  }

  export type CompanyCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | CompanyCountOutputTypeCountUsersArgs
  }

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

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


  /**
   * Count Type OpportunityCountOutputType
   */

  export type OpportunityCountOutputType = {
    likes: number
    comments: number
  }

  export type OpportunityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | OpportunityCountOutputTypeCountLikesArgs
    comments?: boolean | OpportunityCountOutputTypeCountCommentsArgs
  }

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

  /**
   * OpportunityCountOutputType without action
   */
  export type OpportunityCountOutputTypeCountLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OpportunityLikeWhereInput
  }

  /**
   * OpportunityCountOutputType without action
   */
  export type OpportunityCountOutputTypeCountCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OpportunityCommentWhereInput
  }


  /**
   * Count Type EventCountOutputType
   */

  export type EventCountOutputType = {
    likes: number
    comments: number
  }

  export type EventCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | EventCountOutputTypeCountLikesArgs
    comments?: boolean | EventCountOutputTypeCountCommentsArgs
  }

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

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


  /**
   * Count Type AppointmentCountOutputType
   */

  export type AppointmentCountOutputType = {
    likes: number
    comments: number
    registrations: number
  }

  export type AppointmentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | AppointmentCountOutputTypeCountLikesArgs
    comments?: boolean | AppointmentCountOutputTypeCountCommentsArgs
    registrations?: boolean | AppointmentCountOutputTypeCountRegistrationsArgs
  }

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

  /**
   * AppointmentCountOutputType without action
   */
  export type AppointmentCountOutputTypeCountLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentLikeWhereInput
  }

  /**
   * AppointmentCountOutputType without action
   */
  export type AppointmentCountOutputTypeCountCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentCommentWhereInput
  }

  /**
   * AppointmentCountOutputType without action
   */
  export type AppointmentCountOutputTypeCountRegistrationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentRegistrationWhereInput
  }


  /**
   * Models
   */

  /**
   * Model Ccis
   */

  export type AggregateCcis = {
    _count: CcisCountAggregateOutputType | null
    _min: CcisMinAggregateOutputType | null
    _max: CcisMaxAggregateOutputType | null
  }

  export type CcisMinAggregateOutputType = {
    id: string | null
    presentation: string | null
    termsOfService: string | null
    privacyPolicy: string | null
  }

  export type CcisMaxAggregateOutputType = {
    id: string | null
    presentation: string | null
    termsOfService: string | null
    privacyPolicy: string | null
  }

  export type CcisCountAggregateOutputType = {
    id: number
    presentation: number
    termsOfService: number
    privacyPolicy: number
    _all: number
  }


  export type CcisMinAggregateInputType = {
    id?: true
    presentation?: true
    termsOfService?: true
    privacyPolicy?: true
  }

  export type CcisMaxAggregateInputType = {
    id?: true
    presentation?: true
    termsOfService?: true
    privacyPolicy?: true
  }

  export type CcisCountAggregateInputType = {
    id?: true
    presentation?: true
    termsOfService?: true
    privacyPolicy?: true
    _all?: true
  }

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

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




  export type CcisGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CcisWhereInput
    orderBy?: CcisOrderByWithAggregationInput | CcisOrderByWithAggregationInput[]
    by: CcisScalarFieldEnum[] | CcisScalarFieldEnum
    having?: CcisScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CcisCountAggregateInputType | true
    _min?: CcisMinAggregateInputType
    _max?: CcisMaxAggregateInputType
  }

  export type CcisGroupByOutputType = {
    id: string
    presentation: string
    termsOfService: string
    privacyPolicy: string
    _count: CcisCountAggregateOutputType | null
    _min: CcisMinAggregateOutputType | null
    _max: CcisMaxAggregateOutputType | null
  }

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


  export type CcisSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    presentation?: boolean
    termsOfService?: boolean
    privacyPolicy?: boolean
  }, ExtArgs["result"]["ccis"]>

  export type CcisSelectScalar = {
    id?: boolean
    presentation?: boolean
    termsOfService?: boolean
    privacyPolicy?: boolean
  }



  export type $CcisPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Ccis"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      presentation: string
      termsOfService: string
      privacyPolicy: string
    }, ExtArgs["result"]["ccis"]>
    composites: {}
  }


  type CcisGetPayload<S extends boolean | null | undefined | CcisDefaultArgs> = $Result.GetResult<Prisma.$CcisPayload, S>

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

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

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

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

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

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

    /**
     * Create a Ccis.
     * @param {CcisCreateArgs} args - Arguments to create a Ccis.
     * @example
     * // Create one Ccis
     * const Ccis = await prisma.ccis.create({
     *   data: {
     *     // ... data to create a Ccis
     *   }
     * })
     * 
    **/
    create<T extends CcisCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CcisCreateArgs<ExtArgs>>
    ): Prisma__CcisClient<$Result.GetResult<Prisma.$CcisPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Ccis.
     * @param {CcisDeleteArgs} args - Arguments to delete one Ccis.
     * @example
     * // Delete one Ccis
     * const Ccis = await prisma.ccis.delete({
     *   where: {
     *     // ... filter to delete one Ccis
     *   }
     * })
     * 
    **/
    delete<T extends CcisDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CcisDeleteArgs<ExtArgs>>
    ): Prisma__CcisClient<$Result.GetResult<Prisma.$CcisPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Ccis.
     * @param {CcisUpdateArgs} args - Arguments to update one Ccis.
     * @example
     * // Update one Ccis
     * const ccis = await prisma.ccis.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CcisUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CcisUpdateArgs<ExtArgs>>
    ): Prisma__CcisClient<$Result.GetResult<Prisma.$CcisPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Ccis.
   * 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__CcisClient<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 Ccis model
   */ 
  interface CcisFieldRefs {
    readonly id: FieldRef<"Ccis", 'String'>
    readonly presentation: FieldRef<"Ccis", 'String'>
    readonly termsOfService: FieldRef<"Ccis", 'String'>
    readonly privacyPolicy: FieldRef<"Ccis", 'String'>
  }
    

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

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

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

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

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

  /**
   * Ccis create
   */
  export type CcisCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ccis
     */
    select?: CcisSelect<ExtArgs> | null
    /**
     * The data needed to create a Ccis.
     */
    data: XOR<CcisCreateInput, CcisUncheckedCreateInput>
  }

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

  /**
   * Ccis update
   */
  export type CcisUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ccis
     */
    select?: CcisSelect<ExtArgs> | null
    /**
     * The data needed to update a Ccis.
     */
    data: XOR<CcisUpdateInput, CcisUncheckedUpdateInput>
    /**
     * Choose, which Ccis to update.
     */
    where: CcisWhereUniqueInput
  }

  /**
   * Ccis updateMany
   */
  export type CcisUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Ccis.
     */
    data: XOR<CcisUpdateManyMutationInput, CcisUncheckedUpdateManyInput>
    /**
     * Filter which Ccis to update
     */
    where?: CcisWhereInput
  }

  /**
   * Ccis upsert
   */
  export type CcisUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ccis
     */
    select?: CcisSelect<ExtArgs> | null
    /**
     * The filter to search for the Ccis to update in case it exists.
     */
    where: CcisWhereUniqueInput
    /**
     * In case the Ccis found by the `where` argument doesn't exist, create a new Ccis with this data.
     */
    create: XOR<CcisCreateInput, CcisUncheckedCreateInput>
    /**
     * In case the Ccis was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CcisUpdateInput, CcisUncheckedUpdateInput>
  }

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

  /**
   * Ccis deleteMany
   */
  export type CcisDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Ccis to delete
     */
    where?: CcisWhereInput
  }

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


  /**
   * Model Turnover
   */

  export type AggregateTurnover = {
    _count: TurnoverCountAggregateOutputType | null
    _min: TurnoverMinAggregateOutputType | null
    _max: TurnoverMaxAggregateOutputType | null
  }

  export type TurnoverMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type TurnoverMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type TurnoverCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type TurnoverMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type TurnoverMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type TurnoverCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type TurnoverGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TurnoverWhereInput
    orderBy?: TurnoverOrderByWithAggregationInput | TurnoverOrderByWithAggregationInput[]
    by: TurnoverScalarFieldEnum[] | TurnoverScalarFieldEnum
    having?: TurnoverScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TurnoverCountAggregateInputType | true
    _min?: TurnoverMinAggregateInputType
    _max?: TurnoverMaxAggregateInputType
  }

  export type TurnoverGroupByOutputType = {
    id: string
    name: string
    _count: TurnoverCountAggregateOutputType | null
    _min: TurnoverMinAggregateOutputType | null
    _max: TurnoverMaxAggregateOutputType | null
  }

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


  export type TurnoverSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    companies?: boolean | Turnover$companiesArgs<ExtArgs>
    _count?: boolean | TurnoverCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["turnover"]>

  export type TurnoverSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type TurnoverInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    companies?: boolean | Turnover$companiesArgs<ExtArgs>
    _count?: boolean | TurnoverCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $TurnoverPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Turnover"
    objects: {
      companies: Prisma.$CompanyPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["turnover"]>
    composites: {}
  }


  type TurnoverGetPayload<S extends boolean | null | undefined | TurnoverDefaultArgs> = $Result.GetResult<Prisma.$TurnoverPayload, S>

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

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

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

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

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

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

    /**
     * Create a Turnover.
     * @param {TurnoverCreateArgs} args - Arguments to create a Turnover.
     * @example
     * // Create one Turnover
     * const Turnover = await prisma.turnover.create({
     *   data: {
     *     // ... data to create a Turnover
     *   }
     * })
     * 
    **/
    create<T extends TurnoverCreateArgs<ExtArgs>>(
      args: SelectSubset<T, TurnoverCreateArgs<ExtArgs>>
    ): Prisma__TurnoverClient<$Result.GetResult<Prisma.$TurnoverPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Turnover.
     * @param {TurnoverDeleteArgs} args - Arguments to delete one Turnover.
     * @example
     * // Delete one Turnover
     * const Turnover = await prisma.turnover.delete({
     *   where: {
     *     // ... filter to delete one Turnover
     *   }
     * })
     * 
    **/
    delete<T extends TurnoverDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, TurnoverDeleteArgs<ExtArgs>>
    ): Prisma__TurnoverClient<$Result.GetResult<Prisma.$TurnoverPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Turnover.
     * @param {TurnoverUpdateArgs} args - Arguments to update one Turnover.
     * @example
     * // Update one Turnover
     * const turnover = await prisma.turnover.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends TurnoverUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, TurnoverUpdateArgs<ExtArgs>>
    ): Prisma__TurnoverClient<$Result.GetResult<Prisma.$TurnoverPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Turnover.
   * 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__TurnoverClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    companies<T extends Turnover$companiesArgs<ExtArgs> = {}>(args?: Subset<T, Turnover$companiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CompanyPayload<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 Turnover model
   */ 
  interface TurnoverFieldRefs {
    readonly id: FieldRef<"Turnover", 'String'>
    readonly name: FieldRef<"Turnover", 'String'>
  }
    

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

  /**
   * Turnover findUniqueOrThrow
   */
  export type TurnoverFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    /**
     * Filter, which Turnover to fetch.
     */
    where: TurnoverWhereUniqueInput
  }

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

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

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

  /**
   * Turnover create
   */
  export type TurnoverCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    /**
     * The data needed to create a Turnover.
     */
    data: XOR<TurnoverCreateInput, TurnoverUncheckedCreateInput>
  }

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

  /**
   * Turnover update
   */
  export type TurnoverUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    /**
     * The data needed to update a Turnover.
     */
    data: XOR<TurnoverUpdateInput, TurnoverUncheckedUpdateInput>
    /**
     * Choose, which Turnover to update.
     */
    where: TurnoverWhereUniqueInput
  }

  /**
   * Turnover updateMany
   */
  export type TurnoverUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Turnovers.
     */
    data: XOR<TurnoverUpdateManyMutationInput, TurnoverUncheckedUpdateManyInput>
    /**
     * Filter which Turnovers to update
     */
    where?: TurnoverWhereInput
  }

  /**
   * Turnover upsert
   */
  export type TurnoverUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    /**
     * The filter to search for the Turnover to update in case it exists.
     */
    where: TurnoverWhereUniqueInput
    /**
     * In case the Turnover found by the `where` argument doesn't exist, create a new Turnover with this data.
     */
    create: XOR<TurnoverCreateInput, TurnoverUncheckedCreateInput>
    /**
     * In case the Turnover was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TurnoverUpdateInput, TurnoverUncheckedUpdateInput>
  }

  /**
   * Turnover delete
   */
  export type TurnoverDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    /**
     * Filter which Turnover to delete.
     */
    where: TurnoverWhereUniqueInput
  }

  /**
   * Turnover deleteMany
   */
  export type TurnoverDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Turnovers to delete
     */
    where?: TurnoverWhereInput
  }

  /**
   * Turnover.companies
   */
  export type Turnover$companiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    where?: CompanyWhereInput
    orderBy?: CompanyOrderByWithRelationInput | CompanyOrderByWithRelationInput[]
    cursor?: CompanyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CompanyScalarFieldEnum | CompanyScalarFieldEnum[]
  }

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


  /**
   * Model NEmployees
   */

  export type AggregateNEmployees = {
    _count: NEmployeesCountAggregateOutputType | null
    _min: NEmployeesMinAggregateOutputType | null
    _max: NEmployeesMaxAggregateOutputType | null
  }

  export type NEmployeesMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type NEmployeesMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type NEmployeesCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type NEmployeesMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type NEmployeesMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type NEmployeesCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type NEmployeesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NEmployeesWhereInput
    orderBy?: NEmployeesOrderByWithAggregationInput | NEmployeesOrderByWithAggregationInput[]
    by: NEmployeesScalarFieldEnum[] | NEmployeesScalarFieldEnum
    having?: NEmployeesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NEmployeesCountAggregateInputType | true
    _min?: NEmployeesMinAggregateInputType
    _max?: NEmployeesMaxAggregateInputType
  }

  export type NEmployeesGroupByOutputType = {
    id: string
    name: string
    _count: NEmployeesCountAggregateOutputType | null
    _min: NEmployeesMinAggregateOutputType | null
    _max: NEmployeesMaxAggregateOutputType | null
  }

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


  export type NEmployeesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    companies?: boolean | NEmployees$companiesArgs<ExtArgs>
    _count?: boolean | NEmployeesCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["nEmployees"]>

  export type NEmployeesSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type NEmployeesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    companies?: boolean | NEmployees$companiesArgs<ExtArgs>
    _count?: boolean | NEmployeesCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $NEmployeesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "NEmployees"
    objects: {
      companies: Prisma.$CompanyPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["nEmployees"]>
    composites: {}
  }


  type NEmployeesGetPayload<S extends boolean | null | undefined | NEmployeesDefaultArgs> = $Result.GetResult<Prisma.$NEmployeesPayload, S>

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

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

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

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

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

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

    /**
     * Create a NEmployees.
     * @param {NEmployeesCreateArgs} args - Arguments to create a NEmployees.
     * @example
     * // Create one NEmployees
     * const NEmployees = await prisma.nEmployees.create({
     *   data: {
     *     // ... data to create a NEmployees
     *   }
     * })
     * 
    **/
    create<T extends NEmployeesCreateArgs<ExtArgs>>(
      args: SelectSubset<T, NEmployeesCreateArgs<ExtArgs>>
    ): Prisma__NEmployeesClient<$Result.GetResult<Prisma.$NEmployeesPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a NEmployees.
     * @param {NEmployeesDeleteArgs} args - Arguments to delete one NEmployees.
     * @example
     * // Delete one NEmployees
     * const NEmployees = await prisma.nEmployees.delete({
     *   where: {
     *     // ... filter to delete one NEmployees
     *   }
     * })
     * 
    **/
    delete<T extends NEmployeesDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, NEmployeesDeleteArgs<ExtArgs>>
    ): Prisma__NEmployeesClient<$Result.GetResult<Prisma.$NEmployeesPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one NEmployees.
     * @param {NEmployeesUpdateArgs} args - Arguments to update one NEmployees.
     * @example
     * // Update one NEmployees
     * const nEmployees = await prisma.nEmployees.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends NEmployeesUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, NEmployeesUpdateArgs<ExtArgs>>
    ): Prisma__NEmployeesClient<$Result.GetResult<Prisma.$NEmployeesPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for NEmployees.
   * 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__NEmployeesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    companies<T extends NEmployees$companiesArgs<ExtArgs> = {}>(args?: Subset<T, NEmployees$companiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CompanyPayload<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 NEmployees model
   */ 
  interface NEmployeesFieldRefs {
    readonly id: FieldRef<"NEmployees", 'String'>
    readonly name: FieldRef<"NEmployees", 'String'>
  }
    

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

  /**
   * NEmployees findUniqueOrThrow
   */
  export type NEmployeesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    /**
     * Filter, which NEmployees to fetch.
     */
    where: NEmployeesWhereUniqueInput
  }

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

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

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

  /**
   * NEmployees create
   */
  export type NEmployeesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    /**
     * The data needed to create a NEmployees.
     */
    data: XOR<NEmployeesCreateInput, NEmployeesUncheckedCreateInput>
  }

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

  /**
   * NEmployees update
   */
  export type NEmployeesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    /**
     * The data needed to update a NEmployees.
     */
    data: XOR<NEmployeesUpdateInput, NEmployeesUncheckedUpdateInput>
    /**
     * Choose, which NEmployees to update.
     */
    where: NEmployeesWhereUniqueInput
  }

  /**
   * NEmployees updateMany
   */
  export type NEmployeesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update NEmployees.
     */
    data: XOR<NEmployeesUpdateManyMutationInput, NEmployeesUncheckedUpdateManyInput>
    /**
     * Filter which NEmployees to update
     */
    where?: NEmployeesWhereInput
  }

  /**
   * NEmployees upsert
   */
  export type NEmployeesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    /**
     * The filter to search for the NEmployees to update in case it exists.
     */
    where: NEmployeesWhereUniqueInput
    /**
     * In case the NEmployees found by the `where` argument doesn't exist, create a new NEmployees with this data.
     */
    create: XOR<NEmployeesCreateInput, NEmployeesUncheckedCreateInput>
    /**
     * In case the NEmployees was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NEmployeesUpdateInput, NEmployeesUncheckedUpdateInput>
  }

  /**
   * NEmployees delete
   */
  export type NEmployeesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    /**
     * Filter which NEmployees to delete.
     */
    where: NEmployeesWhereUniqueInput
  }

  /**
   * NEmployees deleteMany
   */
  export type NEmployeesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NEmployees to delete
     */
    where?: NEmployeesWhereInput
  }

  /**
   * NEmployees.companies
   */
  export type NEmployees$companiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    where?: CompanyWhereInput
    orderBy?: CompanyOrderByWithRelationInput | CompanyOrderByWithRelationInput[]
    cursor?: CompanyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CompanyScalarFieldEnum | CompanyScalarFieldEnum[]
  }

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


  /**
   * Model City
   */

  export type AggregateCity = {
    _count: CityCountAggregateOutputType | null
    _min: CityMinAggregateOutputType | null
    _max: CityMaxAggregateOutputType | null
  }

  export type CityMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type CityMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type CityCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type CityMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type CityMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type CityCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type CityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CityWhereInput
    orderBy?: CityOrderByWithAggregationInput | CityOrderByWithAggregationInput[]
    by: CityScalarFieldEnum[] | CityScalarFieldEnum
    having?: CityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CityCountAggregateInputType | true
    _min?: CityMinAggregateInputType
    _max?: CityMaxAggregateInputType
  }

  export type CityGroupByOutputType = {
    id: string
    name: string
    _count: CityCountAggregateOutputType | null
    _min: CityMinAggregateOutputType | null
    _max: CityMaxAggregateOutputType | null
  }

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


  export type CitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    users?: boolean | City$usersArgs<ExtArgs>
    companies?: boolean | City$companiesArgs<ExtArgs>
    _count?: boolean | CityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["city"]>

  export type CitySelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type CityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | City$usersArgs<ExtArgs>
    companies?: boolean | City$companiesArgs<ExtArgs>
    _count?: boolean | CityCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $CityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "City"
    objects: {
      users: Prisma.$UserPayload<ExtArgs>[]
      companies: Prisma.$CompanyPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["city"]>
    composites: {}
  }


  type CityGetPayload<S extends boolean | null | undefined | CityDefaultArgs> = $Result.GetResult<Prisma.$CityPayload, S>

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

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

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

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

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

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

    /**
     * Create a City.
     * @param {CityCreateArgs} args - Arguments to create a City.
     * @example
     * // Create one City
     * const City = await prisma.city.create({
     *   data: {
     *     // ... data to create a City
     *   }
     * })
     * 
    **/
    create<T extends CityCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CityCreateArgs<ExtArgs>>
    ): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a City.
     * @param {CityDeleteArgs} args - Arguments to delete one City.
     * @example
     * // Delete one City
     * const City = await prisma.city.delete({
     *   where: {
     *     // ... filter to delete one City
     *   }
     * })
     * 
    **/
    delete<T extends CityDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CityDeleteArgs<ExtArgs>>
    ): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one City.
     * @param {CityUpdateArgs} args - Arguments to update one City.
     * @example
     * // Update one City
     * const city = await prisma.city.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CityUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CityUpdateArgs<ExtArgs>>
    ): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for City.
   * 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__CityClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    users<T extends City$usersArgs<ExtArgs> = {}>(args?: Subset<T, City$usersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findMany'> | Null>;

    companies<T extends City$companiesArgs<ExtArgs> = {}>(args?: Subset<T, City$companiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CompanyPayload<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 City model
   */ 
  interface CityFieldRefs {
    readonly id: FieldRef<"City", 'String'>
    readonly name: FieldRef<"City", 'String'>
  }
    

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

  /**
   * City findUniqueOrThrow
   */
  export type CityFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    /**
     * Filter, which City to fetch.
     */
    where: CityWhereUniqueInput
  }

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

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

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

  /**
   * City create
   */
  export type CityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    /**
     * The data needed to create a City.
     */
    data: XOR<CityCreateInput, CityUncheckedCreateInput>
  }

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

  /**
   * City update
   */
  export type CityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    /**
     * The data needed to update a City.
     */
    data: XOR<CityUpdateInput, CityUncheckedUpdateInput>
    /**
     * Choose, which City to update.
     */
    where: CityWhereUniqueInput
  }

  /**
   * City updateMany
   */
  export type CityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Cities.
     */
    data: XOR<CityUpdateManyMutationInput, CityUncheckedUpdateManyInput>
    /**
     * Filter which Cities to update
     */
    where?: CityWhereInput
  }

  /**
   * City upsert
   */
  export type CityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    /**
     * The filter to search for the City to update in case it exists.
     */
    where: CityWhereUniqueInput
    /**
     * In case the City found by the `where` argument doesn't exist, create a new City with this data.
     */
    create: XOR<CityCreateInput, CityUncheckedCreateInput>
    /**
     * In case the City was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CityUpdateInput, CityUncheckedUpdateInput>
  }

  /**
   * City delete
   */
  export type CityDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    /**
     * Filter which City to delete.
     */
    where: CityWhereUniqueInput
  }

  /**
   * City deleteMany
   */
  export type CityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Cities to delete
     */
    where?: CityWhereInput
  }

  /**
   * City.users
   */
  export type City$usersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * City.companies
   */
  export type City$companiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    where?: CompanyWhereInput
    orderBy?: CompanyOrderByWithRelationInput | CompanyOrderByWithRelationInput[]
    cursor?: CompanyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CompanyScalarFieldEnum | CompanyScalarFieldEnum[]
  }

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


  /**
   * Model Position
   */

  export type AggregatePosition = {
    _count: PositionCountAggregateOutputType | null
    _min: PositionMinAggregateOutputType | null
    _max: PositionMaxAggregateOutputType | null
  }

  export type PositionMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type PositionMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type PositionCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type PositionMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type PositionMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type PositionCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type PositionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PositionWhereInput
    orderBy?: PositionOrderByWithAggregationInput | PositionOrderByWithAggregationInput[]
    by: PositionScalarFieldEnum[] | PositionScalarFieldEnum
    having?: PositionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PositionCountAggregateInputType | true
    _min?: PositionMinAggregateInputType
    _max?: PositionMaxAggregateInputType
  }

  export type PositionGroupByOutputType = {
    id: string
    name: string
    _count: PositionCountAggregateOutputType | null
    _min: PositionMinAggregateOutputType | null
    _max: PositionMaxAggregateOutputType | null
  }

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


  export type PositionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    users?: boolean | Position$usersArgs<ExtArgs>
    companies?: boolean | Position$companiesArgs<ExtArgs>
    electedMembers?: boolean | Position$electedMembersArgs<ExtArgs>
    _count?: boolean | PositionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["position"]>

  export type PositionSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type PositionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    users?: boolean | Position$usersArgs<ExtArgs>
    companies?: boolean | Position$companiesArgs<ExtArgs>
    electedMembers?: boolean | Position$electedMembersArgs<ExtArgs>
    _count?: boolean | PositionCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $PositionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Position"
    objects: {
      users: Prisma.$UserPayload<ExtArgs>[]
      companies: Prisma.$CompanyPayload<ExtArgs>[]
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["position"]>
    composites: {}
  }


  type PositionGetPayload<S extends boolean | null | undefined | PositionDefaultArgs> = $Result.GetResult<Prisma.$PositionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Position.
     * @param {PositionCreateArgs} args - Arguments to create a Position.
     * @example
     * // Create one Position
     * const Position = await prisma.position.create({
     *   data: {
     *     // ... data to create a Position
     *   }
     * })
     * 
    **/
    create<T extends PositionCreateArgs<ExtArgs>>(
      args: SelectSubset<T, PositionCreateArgs<ExtArgs>>
    ): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Position.
     * @param {PositionDeleteArgs} args - Arguments to delete one Position.
     * @example
     * // Delete one Position
     * const Position = await prisma.position.delete({
     *   where: {
     *     // ... filter to delete one Position
     *   }
     * })
     * 
    **/
    delete<T extends PositionDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, PositionDeleteArgs<ExtArgs>>
    ): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Position.
     * @param {PositionUpdateArgs} args - Arguments to update one Position.
     * @example
     * // Update one Position
     * const position = await prisma.position.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends PositionUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, PositionUpdateArgs<ExtArgs>>
    ): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Position.
   * 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__PositionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    users<T extends Position$usersArgs<ExtArgs> = {}>(args?: Subset<T, Position$usersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findMany'> | Null>;

    companies<T extends Position$companiesArgs<ExtArgs> = {}>(args?: Subset<T, Position$companiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CompanyPayload<ExtArgs>, T, 'findMany'> | Null>;

    electedMembers<T extends Position$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, Position$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<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 Position model
   */ 
  interface PositionFieldRefs {
    readonly id: FieldRef<"Position", 'String'>
    readonly name: FieldRef<"Position", 'String'>
  }
    

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

  /**
   * Position findUniqueOrThrow
   */
  export type PositionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    /**
     * Filter, which Position to fetch.
     */
    where: PositionWhereUniqueInput
  }

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

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

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

  /**
   * Position create
   */
  export type PositionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    /**
     * The data needed to create a Position.
     */
    data: XOR<PositionCreateInput, PositionUncheckedCreateInput>
  }

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

  /**
   * Position update
   */
  export type PositionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    /**
     * The data needed to update a Position.
     */
    data: XOR<PositionUpdateInput, PositionUncheckedUpdateInput>
    /**
     * Choose, which Position to update.
     */
    where: PositionWhereUniqueInput
  }

  /**
   * Position updateMany
   */
  export type PositionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Positions.
     */
    data: XOR<PositionUpdateManyMutationInput, PositionUncheckedUpdateManyInput>
    /**
     * Filter which Positions to update
     */
    where?: PositionWhereInput
  }

  /**
   * Position upsert
   */
  export type PositionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    /**
     * The filter to search for the Position to update in case it exists.
     */
    where: PositionWhereUniqueInput
    /**
     * In case the Position found by the `where` argument doesn't exist, create a new Position with this data.
     */
    create: XOR<PositionCreateInput, PositionUncheckedCreateInput>
    /**
     * In case the Position was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PositionUpdateInput, PositionUncheckedUpdateInput>
  }

  /**
   * Position delete
   */
  export type PositionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    /**
     * Filter which Position to delete.
     */
    where: PositionWhereUniqueInput
  }

  /**
   * Position deleteMany
   */
  export type PositionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Positions to delete
     */
    where?: PositionWhereInput
  }

  /**
   * Position.users
   */
  export type Position$usersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * Position.companies
   */
  export type Position$companiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    where?: CompanyWhereInput
    orderBy?: CompanyOrderByWithRelationInput | CompanyOrderByWithRelationInput[]
    cursor?: CompanyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CompanyScalarFieldEnum | CompanyScalarFieldEnum[]
  }

  /**
   * Position.electedMembers
   */
  export type Position$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

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


  /**
   * Model ActivityFamily
   */

  export type AggregateActivityFamily = {
    _count: ActivityFamilyCountAggregateOutputType | null
    _min: ActivityFamilyMinAggregateOutputType | null
    _max: ActivityFamilyMaxAggregateOutputType | null
  }

  export type ActivityFamilyMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ActivityFamilyMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ActivityFamilyCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type ActivityFamilyMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type ActivityFamilyMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type ActivityFamilyCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type ActivityFamilyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ActivityFamilyWhereInput
    orderBy?: ActivityFamilyOrderByWithAggregationInput | ActivityFamilyOrderByWithAggregationInput[]
    by: ActivityFamilyScalarFieldEnum[] | ActivityFamilyScalarFieldEnum
    having?: ActivityFamilyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ActivityFamilyCountAggregateInputType | true
    _min?: ActivityFamilyMinAggregateInputType
    _max?: ActivityFamilyMaxAggregateInputType
  }

  export type ActivityFamilyGroupByOutputType = {
    id: string
    name: string
    _count: ActivityFamilyCountAggregateOutputType | null
    _min: ActivityFamilyMinAggregateOutputType | null
    _max: ActivityFamilyMaxAggregateOutputType | null
  }

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


  export type ActivityFamilySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    activities?: boolean | ActivityFamily$activitiesArgs<ExtArgs>
    electedMembers?: boolean | ActivityFamily$electedMembersArgs<ExtArgs>
    _count?: boolean | ActivityFamilyCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["activityFamily"]>

  export type ActivityFamilySelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type ActivityFamilyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | ActivityFamily$activitiesArgs<ExtArgs>
    electedMembers?: boolean | ActivityFamily$electedMembersArgs<ExtArgs>
    _count?: boolean | ActivityFamilyCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $ActivityFamilyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ActivityFamily"
    objects: {
      activities: Prisma.$ActivityPayload<ExtArgs>[]
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["activityFamily"]>
    composites: {}
  }


  type ActivityFamilyGetPayload<S extends boolean | null | undefined | ActivityFamilyDefaultArgs> = $Result.GetResult<Prisma.$ActivityFamilyPayload, S>

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

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

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

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

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

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

    /**
     * Create a ActivityFamily.
     * @param {ActivityFamilyCreateArgs} args - Arguments to create a ActivityFamily.
     * @example
     * // Create one ActivityFamily
     * const ActivityFamily = await prisma.activityFamily.create({
     *   data: {
     *     // ... data to create a ActivityFamily
     *   }
     * })
     * 
    **/
    create<T extends ActivityFamilyCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityFamilyCreateArgs<ExtArgs>>
    ): Prisma__ActivityFamilyClient<$Result.GetResult<Prisma.$ActivityFamilyPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ActivityFamily.
     * @param {ActivityFamilyDeleteArgs} args - Arguments to delete one ActivityFamily.
     * @example
     * // Delete one ActivityFamily
     * const ActivityFamily = await prisma.activityFamily.delete({
     *   where: {
     *     // ... filter to delete one ActivityFamily
     *   }
     * })
     * 
    **/
    delete<T extends ActivityFamilyDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityFamilyDeleteArgs<ExtArgs>>
    ): Prisma__ActivityFamilyClient<$Result.GetResult<Prisma.$ActivityFamilyPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one ActivityFamily.
     * @param {ActivityFamilyUpdateArgs} args - Arguments to update one ActivityFamily.
     * @example
     * // Update one ActivityFamily
     * const activityFamily = await prisma.activityFamily.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ActivityFamilyUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityFamilyUpdateArgs<ExtArgs>>
    ): Prisma__ActivityFamilyClient<$Result.GetResult<Prisma.$ActivityFamilyPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ActivityFamily.
   * 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__ActivityFamilyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    activities<T extends ActivityFamily$activitiesArgs<ExtArgs> = {}>(args?: Subset<T, ActivityFamily$activitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ActivityPayload<ExtArgs>, T, 'findMany'> | Null>;

    electedMembers<T extends ActivityFamily$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, ActivityFamily$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<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 ActivityFamily model
   */ 
  interface ActivityFamilyFieldRefs {
    readonly id: FieldRef<"ActivityFamily", 'String'>
    readonly name: FieldRef<"ActivityFamily", 'String'>
  }
    

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

  /**
   * ActivityFamily findUniqueOrThrow
   */
  export type ActivityFamilyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ActivityFamily
     */
    select?: ActivityFamilySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityFamilyInclude<ExtArgs> | null
    /**
     * Filter, which ActivityFamily to fetch.
     */
    where: ActivityFamilyWhereUniqueInput
  }

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

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

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

  /**
   * ActivityFamily create
   */
  export type ActivityFamilyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ActivityFamily
     */
    select?: ActivityFamilySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityFamilyInclude<ExtArgs> | null
    /**
     * The data needed to create a ActivityFamily.
     */
    data: XOR<ActivityFamilyCreateInput, ActivityFamilyUncheckedCreateInput>
  }

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

  /**
   * ActivityFamily update
   */
  export type ActivityFamilyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ActivityFamily
     */
    select?: ActivityFamilySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityFamilyInclude<ExtArgs> | null
    /**
     * The data needed to update a ActivityFamily.
     */
    data: XOR<ActivityFamilyUpdateInput, ActivityFamilyUncheckedUpdateInput>
    /**
     * Choose, which ActivityFamily to update.
     */
    where: ActivityFamilyWhereUniqueInput
  }

  /**
   * ActivityFamily updateMany
   */
  export type ActivityFamilyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ActivityFamilies.
     */
    data: XOR<ActivityFamilyUpdateManyMutationInput, ActivityFamilyUncheckedUpdateManyInput>
    /**
     * Filter which ActivityFamilies to update
     */
    where?: ActivityFamilyWhereInput
  }

  /**
   * ActivityFamily upsert
   */
  export type ActivityFamilyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ActivityFamily
     */
    select?: ActivityFamilySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityFamilyInclude<ExtArgs> | null
    /**
     * The filter to search for the ActivityFamily to update in case it exists.
     */
    where: ActivityFamilyWhereUniqueInput
    /**
     * In case the ActivityFamily found by the `where` argument doesn't exist, create a new ActivityFamily with this data.
     */
    create: XOR<ActivityFamilyCreateInput, ActivityFamilyUncheckedCreateInput>
    /**
     * In case the ActivityFamily was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ActivityFamilyUpdateInput, ActivityFamilyUncheckedUpdateInput>
  }

  /**
   * ActivityFamily delete
   */
  export type ActivityFamilyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ActivityFamily
     */
    select?: ActivityFamilySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityFamilyInclude<ExtArgs> | null
    /**
     * Filter which ActivityFamily to delete.
     */
    where: ActivityFamilyWhereUniqueInput
  }

  /**
   * ActivityFamily deleteMany
   */
  export type ActivityFamilyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ActivityFamilies to delete
     */
    where?: ActivityFamilyWhereInput
  }

  /**
   * ActivityFamily.activities
   */
  export type ActivityFamily$activitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    where?: ActivityWhereInput
    orderBy?: ActivityOrderByWithRelationInput | ActivityOrderByWithRelationInput[]
    cursor?: ActivityWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ActivityScalarFieldEnum | ActivityScalarFieldEnum[]
  }

  /**
   * ActivityFamily.electedMembers
   */
  export type ActivityFamily$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

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


  /**
   * Model Activity
   */

  export type AggregateActivity = {
    _count: ActivityCountAggregateOutputType | null
    _min: ActivityMinAggregateOutputType | null
    _max: ActivityMaxAggregateOutputType | null
  }

  export type ActivityMinAggregateOutputType = {
    id: string | null
    name: string | null
    activityFamilyId: string | null
  }

  export type ActivityMaxAggregateOutputType = {
    id: string | null
    name: string | null
    activityFamilyId: string | null
  }

  export type ActivityCountAggregateOutputType = {
    id: number
    name: number
    activityFamilyId: number
    _all: number
  }


  export type ActivityMinAggregateInputType = {
    id?: true
    name?: true
    activityFamilyId?: true
  }

  export type ActivityMaxAggregateInputType = {
    id?: true
    name?: true
    activityFamilyId?: true
  }

  export type ActivityCountAggregateInputType = {
    id?: true
    name?: true
    activityFamilyId?: true
    _all?: true
  }

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

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




  export type ActivityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ActivityWhereInput
    orderBy?: ActivityOrderByWithAggregationInput | ActivityOrderByWithAggregationInput[]
    by: ActivityScalarFieldEnum[] | ActivityScalarFieldEnum
    having?: ActivityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ActivityCountAggregateInputType | true
    _min?: ActivityMinAggregateInputType
    _max?: ActivityMaxAggregateInputType
  }

  export type ActivityGroupByOutputType = {
    id: string
    name: string
    activityFamilyId: string
    _count: ActivityCountAggregateOutputType | null
    _min: ActivityMinAggregateOutputType | null
    _max: ActivityMaxAggregateOutputType | null
  }

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


  export type ActivitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    activityFamilyId?: boolean
    activityFamily?: boolean | ActivityFamilyDefaultArgs<ExtArgs>
    electedMembers?: boolean | Activity$electedMembersArgs<ExtArgs>
    _count?: boolean | ActivityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["activity"]>

  export type ActivitySelectScalar = {
    id?: boolean
    name?: boolean
    activityFamilyId?: boolean
  }


  export type ActivityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activityFamily?: boolean | ActivityFamilyDefaultArgs<ExtArgs>
    electedMembers?: boolean | Activity$electedMembersArgs<ExtArgs>
    _count?: boolean | ActivityCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $ActivityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Activity"
    objects: {
      activityFamily: Prisma.$ActivityFamilyPayload<ExtArgs>
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      activityFamilyId: string
    }, ExtArgs["result"]["activity"]>
    composites: {}
  }


  type ActivityGetPayload<S extends boolean | null | undefined | ActivityDefaultArgs> = $Result.GetResult<Prisma.$ActivityPayload, S>

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

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

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

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

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

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

    /**
     * Create a Activity.
     * @param {ActivityCreateArgs} args - Arguments to create a Activity.
     * @example
     * // Create one Activity
     * const Activity = await prisma.activity.create({
     *   data: {
     *     // ... data to create a Activity
     *   }
     * })
     * 
    **/
    create<T extends ActivityCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityCreateArgs<ExtArgs>>
    ): Prisma__ActivityClient<$Result.GetResult<Prisma.$ActivityPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Activity.
     * @param {ActivityDeleteArgs} args - Arguments to delete one Activity.
     * @example
     * // Delete one Activity
     * const Activity = await prisma.activity.delete({
     *   where: {
     *     // ... filter to delete one Activity
     *   }
     * })
     * 
    **/
    delete<T extends ActivityDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityDeleteArgs<ExtArgs>>
    ): Prisma__ActivityClient<$Result.GetResult<Prisma.$ActivityPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Activity.
     * @param {ActivityUpdateArgs} args - Arguments to update one Activity.
     * @example
     * // Update one Activity
     * const activity = await prisma.activity.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ActivityUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ActivityUpdateArgs<ExtArgs>>
    ): Prisma__ActivityClient<$Result.GetResult<Prisma.$ActivityPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Activity.
   * 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__ActivityClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    activityFamily<T extends ActivityFamilyDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ActivityFamilyDefaultArgs<ExtArgs>>): Prisma__ActivityFamilyClient<$Result.GetResult<Prisma.$ActivityFamilyPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    electedMembers<T extends Activity$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, Activity$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<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 Activity model
   */ 
  interface ActivityFieldRefs {
    readonly id: FieldRef<"Activity", 'String'>
    readonly name: FieldRef<"Activity", 'String'>
    readonly activityFamilyId: FieldRef<"Activity", 'String'>
  }
    

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

  /**
   * Activity findUniqueOrThrow
   */
  export type ActivityFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    /**
     * Filter, which Activity to fetch.
     */
    where: ActivityWhereUniqueInput
  }

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

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

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

  /**
   * Activity create
   */
  export type ActivityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    /**
     * The data needed to create a Activity.
     */
    data: XOR<ActivityCreateInput, ActivityUncheckedCreateInput>
  }

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

  /**
   * Activity update
   */
  export type ActivityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    /**
     * The data needed to update a Activity.
     */
    data: XOR<ActivityUpdateInput, ActivityUncheckedUpdateInput>
    /**
     * Choose, which Activity to update.
     */
    where: ActivityWhereUniqueInput
  }

  /**
   * Activity updateMany
   */
  export type ActivityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Activities.
     */
    data: XOR<ActivityUpdateManyMutationInput, ActivityUncheckedUpdateManyInput>
    /**
     * Filter which Activities to update
     */
    where?: ActivityWhereInput
  }

  /**
   * Activity upsert
   */
  export type ActivityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    /**
     * The filter to search for the Activity to update in case it exists.
     */
    where: ActivityWhereUniqueInput
    /**
     * In case the Activity found by the `where` argument doesn't exist, create a new Activity with this data.
     */
    create: XOR<ActivityCreateInput, ActivityUncheckedCreateInput>
    /**
     * In case the Activity was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ActivityUpdateInput, ActivityUncheckedUpdateInput>
  }

  /**
   * Activity delete
   */
  export type ActivityDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Activity
     */
    select?: ActivitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ActivityInclude<ExtArgs> | null
    /**
     * Filter which Activity to delete.
     */
    where: ActivityWhereUniqueInput
  }

  /**
   * Activity deleteMany
   */
  export type ActivityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Activities to delete
     */
    where?: ActivityWhereInput
  }

  /**
   * Activity.electedMembers
   */
  export type Activity$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

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


  /**
   * Model ExpertiseArea
   */

  export type AggregateExpertiseArea = {
    _count: ExpertiseAreaCountAggregateOutputType | null
    _min: ExpertiseAreaMinAggregateOutputType | null
    _max: ExpertiseAreaMaxAggregateOutputType | null
  }

  export type ExpertiseAreaMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ExpertiseAreaMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ExpertiseAreaCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type ExpertiseAreaMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type ExpertiseAreaMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type ExpertiseAreaCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type ExpertiseAreaGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExpertiseAreaWhereInput
    orderBy?: ExpertiseAreaOrderByWithAggregationInput | ExpertiseAreaOrderByWithAggregationInput[]
    by: ExpertiseAreaScalarFieldEnum[] | ExpertiseAreaScalarFieldEnum
    having?: ExpertiseAreaScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExpertiseAreaCountAggregateInputType | true
    _min?: ExpertiseAreaMinAggregateInputType
    _max?: ExpertiseAreaMaxAggregateInputType
  }

  export type ExpertiseAreaGroupByOutputType = {
    id: string
    name: string
    _count: ExpertiseAreaCountAggregateOutputType | null
    _min: ExpertiseAreaMinAggregateOutputType | null
    _max: ExpertiseAreaMaxAggregateOutputType | null
  }

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


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

  export type ExpertiseAreaSelectScalar = {
    id?: boolean
    name?: boolean
  }



  export type $ExpertiseAreaPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ExpertiseArea"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["expertiseArea"]>
    composites: {}
  }


  type ExpertiseAreaGetPayload<S extends boolean | null | undefined | ExpertiseAreaDefaultArgs> = $Result.GetResult<Prisma.$ExpertiseAreaPayload, S>

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

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

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

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

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

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

    /**
     * Create a ExpertiseArea.
     * @param {ExpertiseAreaCreateArgs} args - Arguments to create a ExpertiseArea.
     * @example
     * // Create one ExpertiseArea
     * const ExpertiseArea = await prisma.expertiseArea.create({
     *   data: {
     *     // ... data to create a ExpertiseArea
     *   }
     * })
     * 
    **/
    create<T extends ExpertiseAreaCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ExpertiseAreaCreateArgs<ExtArgs>>
    ): Prisma__ExpertiseAreaClient<$Result.GetResult<Prisma.$ExpertiseAreaPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ExpertiseArea.
     * @param {ExpertiseAreaDeleteArgs} args - Arguments to delete one ExpertiseArea.
     * @example
     * // Delete one ExpertiseArea
     * const ExpertiseArea = await prisma.expertiseArea.delete({
     *   where: {
     *     // ... filter to delete one ExpertiseArea
     *   }
     * })
     * 
    **/
    delete<T extends ExpertiseAreaDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ExpertiseAreaDeleteArgs<ExtArgs>>
    ): Prisma__ExpertiseAreaClient<$Result.GetResult<Prisma.$ExpertiseAreaPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one ExpertiseArea.
     * @param {ExpertiseAreaUpdateArgs} args - Arguments to update one ExpertiseArea.
     * @example
     * // Update one ExpertiseArea
     * const expertiseArea = await prisma.expertiseArea.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ExpertiseAreaUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ExpertiseAreaUpdateArgs<ExtArgs>>
    ): Prisma__ExpertiseAreaClient<$Result.GetResult<Prisma.$ExpertiseAreaPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ExpertiseArea.
   * 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__ExpertiseAreaClient<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 ExpertiseArea model
   */ 
  interface ExpertiseAreaFieldRefs {
    readonly id: FieldRef<"ExpertiseArea", 'String'>
    readonly name: FieldRef<"ExpertiseArea", 'String'>
  }
    

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

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

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

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

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

  /**
   * ExpertiseArea create
   */
  export type ExpertiseAreaCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertiseArea
     */
    select?: ExpertiseAreaSelect<ExtArgs> | null
    /**
     * The data needed to create a ExpertiseArea.
     */
    data: XOR<ExpertiseAreaCreateInput, ExpertiseAreaUncheckedCreateInput>
  }

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

  /**
   * ExpertiseArea update
   */
  export type ExpertiseAreaUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertiseArea
     */
    select?: ExpertiseAreaSelect<ExtArgs> | null
    /**
     * The data needed to update a ExpertiseArea.
     */
    data: XOR<ExpertiseAreaUpdateInput, ExpertiseAreaUncheckedUpdateInput>
    /**
     * Choose, which ExpertiseArea to update.
     */
    where: ExpertiseAreaWhereUniqueInput
  }

  /**
   * ExpertiseArea updateMany
   */
  export type ExpertiseAreaUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ExpertiseAreas.
     */
    data: XOR<ExpertiseAreaUpdateManyMutationInput, ExpertiseAreaUncheckedUpdateManyInput>
    /**
     * Filter which ExpertiseAreas to update
     */
    where?: ExpertiseAreaWhereInput
  }

  /**
   * ExpertiseArea upsert
   */
  export type ExpertiseAreaUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExpertiseArea
     */
    select?: ExpertiseAreaSelect<ExtArgs> | null
    /**
     * The filter to search for the ExpertiseArea to update in case it exists.
     */
    where: ExpertiseAreaWhereUniqueInput
    /**
     * In case the ExpertiseArea found by the `where` argument doesn't exist, create a new ExpertiseArea with this data.
     */
    create: XOR<ExpertiseAreaCreateInput, ExpertiseAreaUncheckedCreateInput>
    /**
     * In case the ExpertiseArea was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExpertiseAreaUpdateInput, ExpertiseAreaUncheckedUpdateInput>
  }

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

  /**
   * ExpertiseArea deleteMany
   */
  export type ExpertiseAreaDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExpertiseAreas to delete
     */
    where?: ExpertiseAreaWhereInput
  }

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


  /**
   * Model InterestArea
   */

  export type AggregateInterestArea = {
    _count: InterestAreaCountAggregateOutputType | null
    _min: InterestAreaMinAggregateOutputType | null
    _max: InterestAreaMaxAggregateOutputType | null
  }

  export type InterestAreaMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type InterestAreaMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type InterestAreaCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type InterestAreaMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type InterestAreaMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type InterestAreaCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type InterestAreaGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: InterestAreaWhereInput
    orderBy?: InterestAreaOrderByWithAggregationInput | InterestAreaOrderByWithAggregationInput[]
    by: InterestAreaScalarFieldEnum[] | InterestAreaScalarFieldEnum
    having?: InterestAreaScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: InterestAreaCountAggregateInputType | true
    _min?: InterestAreaMinAggregateInputType
    _max?: InterestAreaMaxAggregateInputType
  }

  export type InterestAreaGroupByOutputType = {
    id: string
    name: string
    _count: InterestAreaCountAggregateOutputType | null
    _min: InterestAreaMinAggregateOutputType | null
    _max: InterestAreaMaxAggregateOutputType | null
  }

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


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

  export type InterestAreaSelectScalar = {
    id?: boolean
    name?: boolean
  }



  export type $InterestAreaPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "InterestArea"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["interestArea"]>
    composites: {}
  }


  type InterestAreaGetPayload<S extends boolean | null | undefined | InterestAreaDefaultArgs> = $Result.GetResult<Prisma.$InterestAreaPayload, S>

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

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

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

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

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

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

    /**
     * Create a InterestArea.
     * @param {InterestAreaCreateArgs} args - Arguments to create a InterestArea.
     * @example
     * // Create one InterestArea
     * const InterestArea = await prisma.interestArea.create({
     *   data: {
     *     // ... data to create a InterestArea
     *   }
     * })
     * 
    **/
    create<T extends InterestAreaCreateArgs<ExtArgs>>(
      args: SelectSubset<T, InterestAreaCreateArgs<ExtArgs>>
    ): Prisma__InterestAreaClient<$Result.GetResult<Prisma.$InterestAreaPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a InterestArea.
     * @param {InterestAreaDeleteArgs} args - Arguments to delete one InterestArea.
     * @example
     * // Delete one InterestArea
     * const InterestArea = await prisma.interestArea.delete({
     *   where: {
     *     // ... filter to delete one InterestArea
     *   }
     * })
     * 
    **/
    delete<T extends InterestAreaDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, InterestAreaDeleteArgs<ExtArgs>>
    ): Prisma__InterestAreaClient<$Result.GetResult<Prisma.$InterestAreaPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one InterestArea.
     * @param {InterestAreaUpdateArgs} args - Arguments to update one InterestArea.
     * @example
     * // Update one InterestArea
     * const interestArea = await prisma.interestArea.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends InterestAreaUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, InterestAreaUpdateArgs<ExtArgs>>
    ): Prisma__InterestAreaClient<$Result.GetResult<Prisma.$InterestAreaPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for InterestArea.
   * 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__InterestAreaClient<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 InterestArea model
   */ 
  interface InterestAreaFieldRefs {
    readonly id: FieldRef<"InterestArea", 'String'>
    readonly name: FieldRef<"InterestArea", 'String'>
  }
    

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

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

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

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

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

  /**
   * InterestArea create
   */
  export type InterestAreaCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InterestArea
     */
    select?: InterestAreaSelect<ExtArgs> | null
    /**
     * The data needed to create a InterestArea.
     */
    data: XOR<InterestAreaCreateInput, InterestAreaUncheckedCreateInput>
  }

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

  /**
   * InterestArea update
   */
  export type InterestAreaUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InterestArea
     */
    select?: InterestAreaSelect<ExtArgs> | null
    /**
     * The data needed to update a InterestArea.
     */
    data: XOR<InterestAreaUpdateInput, InterestAreaUncheckedUpdateInput>
    /**
     * Choose, which InterestArea to update.
     */
    where: InterestAreaWhereUniqueInput
  }

  /**
   * InterestArea updateMany
   */
  export type InterestAreaUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update InterestAreas.
     */
    data: XOR<InterestAreaUpdateManyMutationInput, InterestAreaUncheckedUpdateManyInput>
    /**
     * Filter which InterestAreas to update
     */
    where?: InterestAreaWhereInput
  }

  /**
   * InterestArea upsert
   */
  export type InterestAreaUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InterestArea
     */
    select?: InterestAreaSelect<ExtArgs> | null
    /**
     * The filter to search for the InterestArea to update in case it exists.
     */
    where: InterestAreaWhereUniqueInput
    /**
     * In case the InterestArea found by the `where` argument doesn't exist, create a new InterestArea with this data.
     */
    create: XOR<InterestAreaCreateInput, InterestAreaUncheckedCreateInput>
    /**
     * In case the InterestArea was found with the provided `where` argument, update it with this data.
     */
    update: XOR<InterestAreaUpdateInput, InterestAreaUncheckedUpdateInput>
  }

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

  /**
   * InterestArea deleteMany
   */
  export type InterestAreaDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InterestAreas to delete
     */
    where?: InterestAreaWhereInput
  }

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


  /**
   * Model Province
   */

  export type AggregateProvince = {
    _count: ProvinceCountAggregateOutputType | null
    _min: ProvinceMinAggregateOutputType | null
    _max: ProvinceMaxAggregateOutputType | null
  }

  export type ProvinceMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ProvinceMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type ProvinceCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type ProvinceMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type ProvinceMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type ProvinceCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type ProvinceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProvinceWhereInput
    orderBy?: ProvinceOrderByWithAggregationInput | ProvinceOrderByWithAggregationInput[]
    by: ProvinceScalarFieldEnum[] | ProvinceScalarFieldEnum
    having?: ProvinceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProvinceCountAggregateInputType | true
    _min?: ProvinceMinAggregateInputType
    _max?: ProvinceMaxAggregateInputType
  }

  export type ProvinceGroupByOutputType = {
    id: string
    name: string
    _count: ProvinceCountAggregateOutputType | null
    _min: ProvinceMinAggregateOutputType | null
    _max: ProvinceMaxAggregateOutputType | null
  }

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


  export type ProvinceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    electedMembers?: boolean | Province$electedMembersArgs<ExtArgs>
    user?: boolean | Province$userArgs<ExtArgs>
    _count?: boolean | ProvinceCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["province"]>

  export type ProvinceSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type ProvinceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | Province$electedMembersArgs<ExtArgs>
    user?: boolean | Province$userArgs<ExtArgs>
    _count?: boolean | ProvinceCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $ProvincePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Province"
    objects: {
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["province"]>
    composites: {}
  }


  type ProvinceGetPayload<S extends boolean | null | undefined | ProvinceDefaultArgs> = $Result.GetResult<Prisma.$ProvincePayload, S>

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

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

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

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

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

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

    /**
     * Create a Province.
     * @param {ProvinceCreateArgs} args - Arguments to create a Province.
     * @example
     * // Create one Province
     * const Province = await prisma.province.create({
     *   data: {
     *     // ... data to create a Province
     *   }
     * })
     * 
    **/
    create<T extends ProvinceCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ProvinceCreateArgs<ExtArgs>>
    ): Prisma__ProvinceClient<$Result.GetResult<Prisma.$ProvincePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Province.
     * @param {ProvinceDeleteArgs} args - Arguments to delete one Province.
     * @example
     * // Delete one Province
     * const Province = await prisma.province.delete({
     *   where: {
     *     // ... filter to delete one Province
     *   }
     * })
     * 
    **/
    delete<T extends ProvinceDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ProvinceDeleteArgs<ExtArgs>>
    ): Prisma__ProvinceClient<$Result.GetResult<Prisma.$ProvincePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Province.
     * @param {ProvinceUpdateArgs} args - Arguments to update one Province.
     * @example
     * // Update one Province
     * const province = await prisma.province.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ProvinceUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ProvinceUpdateArgs<ExtArgs>>
    ): Prisma__ProvinceClient<$Result.GetResult<Prisma.$ProvincePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Province.
   * 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__ProvinceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    electedMembers<T extends Province$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, Province$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'findMany'> | Null>;

    user<T extends Province$userArgs<ExtArgs> = {}>(args?: Subset<T, Province$userArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<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 Province model
   */ 
  interface ProvinceFieldRefs {
    readonly id: FieldRef<"Province", 'String'>
    readonly name: FieldRef<"Province", 'String'>
  }
    

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

  /**
   * Province findUniqueOrThrow
   */
  export type ProvinceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    /**
     * Filter, which Province to fetch.
     */
    where: ProvinceWhereUniqueInput
  }

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

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

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

  /**
   * Province create
   */
  export type ProvinceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    /**
     * The data needed to create a Province.
     */
    data: XOR<ProvinceCreateInput, ProvinceUncheckedCreateInput>
  }

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

  /**
   * Province update
   */
  export type ProvinceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    /**
     * The data needed to update a Province.
     */
    data: XOR<ProvinceUpdateInput, ProvinceUncheckedUpdateInput>
    /**
     * Choose, which Province to update.
     */
    where: ProvinceWhereUniqueInput
  }

  /**
   * Province updateMany
   */
  export type ProvinceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Provinces.
     */
    data: XOR<ProvinceUpdateManyMutationInput, ProvinceUncheckedUpdateManyInput>
    /**
     * Filter which Provinces to update
     */
    where?: ProvinceWhereInput
  }

  /**
   * Province upsert
   */
  export type ProvinceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    /**
     * The filter to search for the Province to update in case it exists.
     */
    where: ProvinceWhereUniqueInput
    /**
     * In case the Province found by the `where` argument doesn't exist, create a new Province with this data.
     */
    create: XOR<ProvinceCreateInput, ProvinceUncheckedCreateInput>
    /**
     * In case the Province was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProvinceUpdateInput, ProvinceUncheckedUpdateInput>
  }

  /**
   * Province delete
   */
  export type ProvinceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    /**
     * Filter which Province to delete.
     */
    where: ProvinceWhereUniqueInput
  }

  /**
   * Province deleteMany
   */
  export type ProvinceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Provinces to delete
     */
    where?: ProvinceWhereInput
  }

  /**
   * Province.electedMembers
   */
  export type Province$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

  /**
   * Province.user
   */
  export type Province$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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


  /**
   * Model Category
   */

  export type AggregateCategory = {
    _count: CategoryCountAggregateOutputType | null
    _min: CategoryMinAggregateOutputType | null
    _max: CategoryMaxAggregateOutputType | null
  }

  export type CategoryMinAggregateOutputType = {
    id: string | null
    name: string | null
    nameAr: string | null
  }

  export type CategoryMaxAggregateOutputType = {
    id: string | null
    name: string | null
    nameAr: string | null
  }

  export type CategoryCountAggregateOutputType = {
    id: number
    name: number
    nameAr: number
    _all: number
  }


  export type CategoryMinAggregateInputType = {
    id?: true
    name?: true
    nameAr?: true
  }

  export type CategoryMaxAggregateInputType = {
    id?: true
    name?: true
    nameAr?: true
  }

  export type CategoryCountAggregateInputType = {
    id?: true
    name?: true
    nameAr?: true
    _all?: true
  }

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

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




  export type CategoryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CategoryWhereInput
    orderBy?: CategoryOrderByWithAggregationInput | CategoryOrderByWithAggregationInput[]
    by: CategoryScalarFieldEnum[] | CategoryScalarFieldEnum
    having?: CategoryScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CategoryCountAggregateInputType | true
    _min?: CategoryMinAggregateInputType
    _max?: CategoryMaxAggregateInputType
  }

  export type CategoryGroupByOutputType = {
    id: string
    name: string
    nameAr: string
    _count: CategoryCountAggregateOutputType | null
    _min: CategoryMinAggregateOutputType | null
    _max: CategoryMaxAggregateOutputType | null
  }

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


  export type CategorySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    nameAr?: boolean
    editions?: boolean | Category$editionsArgs<ExtArgs>
    _count?: boolean | CategoryCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["category"]>

  export type CategorySelectScalar = {
    id?: boolean
    name?: boolean
    nameAr?: boolean
  }


  export type CategoryInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    editions?: boolean | Category$editionsArgs<ExtArgs>
    _count?: boolean | CategoryCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $CategoryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Category"
    objects: {
      editions: Prisma.$EditionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      nameAr: string
    }, ExtArgs["result"]["category"]>
    composites: {}
  }


  type CategoryGetPayload<S extends boolean | null | undefined | CategoryDefaultArgs> = $Result.GetResult<Prisma.$CategoryPayload, S>

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

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

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

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

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

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

    /**
     * Create a Category.
     * @param {CategoryCreateArgs} args - Arguments to create a Category.
     * @example
     * // Create one Category
     * const Category = await prisma.category.create({
     *   data: {
     *     // ... data to create a Category
     *   }
     * })
     * 
    **/
    create<T extends CategoryCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CategoryCreateArgs<ExtArgs>>
    ): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Category.
     * @param {CategoryDeleteArgs} args - Arguments to delete one Category.
     * @example
     * // Delete one Category
     * const Category = await prisma.category.delete({
     *   where: {
     *     // ... filter to delete one Category
     *   }
     * })
     * 
    **/
    delete<T extends CategoryDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CategoryDeleteArgs<ExtArgs>>
    ): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Category.
     * @param {CategoryUpdateArgs} args - Arguments to update one Category.
     * @example
     * // Update one Category
     * const category = await prisma.category.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CategoryUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CategoryUpdateArgs<ExtArgs>>
    ): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Category.
   * 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__CategoryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    editions<T extends Category$editionsArgs<ExtArgs> = {}>(args?: Subset<T, Category$editionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EditionPayload<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 Category model
   */ 
  interface CategoryFieldRefs {
    readonly id: FieldRef<"Category", 'String'>
    readonly name: FieldRef<"Category", 'String'>
    readonly nameAr: FieldRef<"Category", 'String'>
  }
    

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

  /**
   * Category findUniqueOrThrow
   */
  export type CategoryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryInclude<ExtArgs> | null
    /**
     * Filter, which Category to fetch.
     */
    where: CategoryWhereUniqueInput
  }

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

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

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

  /**
   * Category create
   */
  export type CategoryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryInclude<ExtArgs> | null
    /**
     * The data needed to create a Category.
     */
    data: XOR<CategoryCreateInput, CategoryUncheckedCreateInput>
  }

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

  /**
   * Category update
   */
  export type CategoryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryInclude<ExtArgs> | null
    /**
     * The data needed to update a Category.
     */
    data: XOR<CategoryUpdateInput, CategoryUncheckedUpdateInput>
    /**
     * Choose, which Category to update.
     */
    where: CategoryWhereUniqueInput
  }

  /**
   * Category updateMany
   */
  export type CategoryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Categories.
     */
    data: XOR<CategoryUpdateManyMutationInput, CategoryUncheckedUpdateManyInput>
    /**
     * Filter which Categories to update
     */
    where?: CategoryWhereInput
  }

  /**
   * Category upsert
   */
  export type CategoryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryInclude<ExtArgs> | null
    /**
     * The filter to search for the Category to update in case it exists.
     */
    where: CategoryWhereUniqueInput
    /**
     * In case the Category found by the `where` argument doesn't exist, create a new Category with this data.
     */
    create: XOR<CategoryCreateInput, CategoryUncheckedCreateInput>
    /**
     * In case the Category was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CategoryUpdateInput, CategoryUncheckedUpdateInput>
  }

  /**
   * Category delete
   */
  export type CategoryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryInclude<ExtArgs> | null
    /**
     * Filter which Category to delete.
     */
    where: CategoryWhereUniqueInput
  }

  /**
   * Category deleteMany
   */
  export type CategoryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Categories to delete
     */
    where?: CategoryWhereInput
  }

  /**
   * Category.editions
   */
  export type Category$editionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    where?: EditionWhereInput
    orderBy?: EditionOrderByWithRelationInput | EditionOrderByWithRelationInput[]
    cursor?: EditionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EditionScalarFieldEnum | EditionScalarFieldEnum[]
  }

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


  /**
   * Model Commission
   */

  export type AggregateCommission = {
    _count: CommissionCountAggregateOutputType | null
    _min: CommissionMinAggregateOutputType | null
    _max: CommissionMaxAggregateOutputType | null
  }

  export type CommissionMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
  }

  export type CommissionMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
  }

  export type CommissionCountAggregateOutputType = {
    id: number
    name: number
    description: number
    _all: number
  }


  export type CommissionMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
  }

  export type CommissionMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
  }

  export type CommissionCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    _all?: true
  }

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

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




  export type CommissionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommissionWhereInput
    orderBy?: CommissionOrderByWithAggregationInput | CommissionOrderByWithAggregationInput[]
    by: CommissionScalarFieldEnum[] | CommissionScalarFieldEnum
    having?: CommissionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommissionCountAggregateInputType | true
    _min?: CommissionMinAggregateInputType
    _max?: CommissionMaxAggregateInputType
  }

  export type CommissionGroupByOutputType = {
    id: string
    name: string
    description: string
    _count: CommissionCountAggregateOutputType | null
    _min: CommissionMinAggregateOutputType | null
    _max: CommissionMaxAggregateOutputType | null
  }

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


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

  export type CommissionSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
  }



  export type $CommissionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Commission"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string
    }, ExtArgs["result"]["commission"]>
    composites: {}
  }


  type CommissionGetPayload<S extends boolean | null | undefined | CommissionDefaultArgs> = $Result.GetResult<Prisma.$CommissionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Commission.
     * @param {CommissionCreateArgs} args - Arguments to create a Commission.
     * @example
     * // Create one Commission
     * const Commission = await prisma.commission.create({
     *   data: {
     *     // ... data to create a Commission
     *   }
     * })
     * 
    **/
    create<T extends CommissionCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CommissionCreateArgs<ExtArgs>>
    ): Prisma__CommissionClient<$Result.GetResult<Prisma.$CommissionPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Commission.
     * @param {CommissionDeleteArgs} args - Arguments to delete one Commission.
     * @example
     * // Delete one Commission
     * const Commission = await prisma.commission.delete({
     *   where: {
     *     // ... filter to delete one Commission
     *   }
     * })
     * 
    **/
    delete<T extends CommissionDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CommissionDeleteArgs<ExtArgs>>
    ): Prisma__CommissionClient<$Result.GetResult<Prisma.$CommissionPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Commission.
     * @param {CommissionUpdateArgs} args - Arguments to update one Commission.
     * @example
     * // Update one Commission
     * const commission = await prisma.commission.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CommissionUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CommissionUpdateArgs<ExtArgs>>
    ): Prisma__CommissionClient<$Result.GetResult<Prisma.$CommissionPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Commission.
   * 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__CommissionClient<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 Commission model
   */ 
  interface CommissionFieldRefs {
    readonly id: FieldRef<"Commission", 'String'>
    readonly name: FieldRef<"Commission", 'String'>
    readonly description: FieldRef<"Commission", 'String'>
  }
    

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

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

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

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

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

  /**
   * Commission create
   */
  export type CommissionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commission
     */
    select?: CommissionSelect<ExtArgs> | null
    /**
     * The data needed to create a Commission.
     */
    data: XOR<CommissionCreateInput, CommissionUncheckedCreateInput>
  }

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

  /**
   * Commission update
   */
  export type CommissionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commission
     */
    select?: CommissionSelect<ExtArgs> | null
    /**
     * The data needed to update a Commission.
     */
    data: XOR<CommissionUpdateInput, CommissionUncheckedUpdateInput>
    /**
     * Choose, which Commission to update.
     */
    where: CommissionWhereUniqueInput
  }

  /**
   * Commission updateMany
   */
  export type CommissionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Commissions.
     */
    data: XOR<CommissionUpdateManyMutationInput, CommissionUncheckedUpdateManyInput>
    /**
     * Filter which Commissions to update
     */
    where?: CommissionWhereInput
  }

  /**
   * Commission upsert
   */
  export type CommissionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commission
     */
    select?: CommissionSelect<ExtArgs> | null
    /**
     * The filter to search for the Commission to update in case it exists.
     */
    where: CommissionWhereUniqueInput
    /**
     * In case the Commission found by the `where` argument doesn't exist, create a new Commission with this data.
     */
    create: XOR<CommissionCreateInput, CommissionUncheckedCreateInput>
    /**
     * In case the Commission was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommissionUpdateInput, CommissionUncheckedUpdateInput>
  }

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

  /**
   * Commission deleteMany
   */
  export type CommissionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Commissions to delete
     */
    where?: CommissionWhereInput
  }

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


  /**
   * Model Mandate
   */

  export type AggregateMandate = {
    _count: MandateCountAggregateOutputType | null
    _min: MandateMinAggregateOutputType | null
    _max: MandateMaxAggregateOutputType | null
  }

  export type MandateMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type MandateMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type MandateCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type MandateMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type MandateMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type MandateCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type MandateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MandateWhereInput
    orderBy?: MandateOrderByWithAggregationInput | MandateOrderByWithAggregationInput[]
    by: MandateScalarFieldEnum[] | MandateScalarFieldEnum
    having?: MandateScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MandateCountAggregateInputType | true
    _min?: MandateMinAggregateInputType
    _max?: MandateMaxAggregateInputType
  }

  export type MandateGroupByOutputType = {
    id: string
    name: string
    _count: MandateCountAggregateOutputType | null
    _min: MandateMinAggregateOutputType | null
    _max: MandateMaxAggregateOutputType | null
  }

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


  export type MandateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    electedMembers?: boolean | Mandate$electedMembersArgs<ExtArgs>
    user?: boolean | Mandate$userArgs<ExtArgs>
    _count?: boolean | MandateCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mandate"]>

  export type MandateSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type MandateInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | Mandate$electedMembersArgs<ExtArgs>
    user?: boolean | Mandate$userArgs<ExtArgs>
    _count?: boolean | MandateCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $MandatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Mandate"
    objects: {
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["mandate"]>
    composites: {}
  }


  type MandateGetPayload<S extends boolean | null | undefined | MandateDefaultArgs> = $Result.GetResult<Prisma.$MandatePayload, S>

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

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

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

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

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

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

    /**
     * Create a Mandate.
     * @param {MandateCreateArgs} args - Arguments to create a Mandate.
     * @example
     * // Create one Mandate
     * const Mandate = await prisma.mandate.create({
     *   data: {
     *     // ... data to create a Mandate
     *   }
     * })
     * 
    **/
    create<T extends MandateCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MandateCreateArgs<ExtArgs>>
    ): Prisma__MandateClient<$Result.GetResult<Prisma.$MandatePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Mandate.
     * @param {MandateDeleteArgs} args - Arguments to delete one Mandate.
     * @example
     * // Delete one Mandate
     * const Mandate = await prisma.mandate.delete({
     *   where: {
     *     // ... filter to delete one Mandate
     *   }
     * })
     * 
    **/
    delete<T extends MandateDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MandateDeleteArgs<ExtArgs>>
    ): Prisma__MandateClient<$Result.GetResult<Prisma.$MandatePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Mandate.
     * @param {MandateUpdateArgs} args - Arguments to update one Mandate.
     * @example
     * // Update one Mandate
     * const mandate = await prisma.mandate.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MandateUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, MandateUpdateArgs<ExtArgs>>
    ): Prisma__MandateClient<$Result.GetResult<Prisma.$MandatePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Mandate.
   * 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__MandateClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    electedMembers<T extends Mandate$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, Mandate$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'findMany'> | Null>;

    user<T extends Mandate$userArgs<ExtArgs> = {}>(args?: Subset<T, Mandate$userArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<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 Mandate model
   */ 
  interface MandateFieldRefs {
    readonly id: FieldRef<"Mandate", 'String'>
    readonly name: FieldRef<"Mandate", 'String'>
  }
    

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

  /**
   * Mandate findUniqueOrThrow
   */
  export type MandateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    /**
     * Filter, which Mandate to fetch.
     */
    where: MandateWhereUniqueInput
  }

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

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

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

  /**
   * Mandate create
   */
  export type MandateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    /**
     * The data needed to create a Mandate.
     */
    data: XOR<MandateCreateInput, MandateUncheckedCreateInput>
  }

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

  /**
   * Mandate update
   */
  export type MandateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    /**
     * The data needed to update a Mandate.
     */
    data: XOR<MandateUpdateInput, MandateUncheckedUpdateInput>
    /**
     * Choose, which Mandate to update.
     */
    where: MandateWhereUniqueInput
  }

  /**
   * Mandate updateMany
   */
  export type MandateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Mandates.
     */
    data: XOR<MandateUpdateManyMutationInput, MandateUncheckedUpdateManyInput>
    /**
     * Filter which Mandates to update
     */
    where?: MandateWhereInput
  }

  /**
   * Mandate upsert
   */
  export type MandateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    /**
     * The filter to search for the Mandate to update in case it exists.
     */
    where: MandateWhereUniqueInput
    /**
     * In case the Mandate found by the `where` argument doesn't exist, create a new Mandate with this data.
     */
    create: XOR<MandateCreateInput, MandateUncheckedCreateInput>
    /**
     * In case the Mandate was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MandateUpdateInput, MandateUncheckedUpdateInput>
  }

  /**
   * Mandate delete
   */
  export type MandateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    /**
     * Filter which Mandate to delete.
     */
    where: MandateWhereUniqueInput
  }

  /**
   * Mandate deleteMany
   */
  export type MandateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Mandates to delete
     */
    where?: MandateWhereInput
  }

  /**
   * Mandate.electedMembers
   */
  export type Mandate$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

  /**
   * Mandate.user
   */
  export type Mandate$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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


  /**
   * Model College
   */

  export type AggregateCollege = {
    _count: CollegeCountAggregateOutputType | null
    _min: CollegeMinAggregateOutputType | null
    _max: CollegeMaxAggregateOutputType | null
  }

  export type CollegeMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type CollegeMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type CollegeCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type CollegeMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type CollegeMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type CollegeCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

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

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




  export type CollegeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CollegeWhereInput
    orderBy?: CollegeOrderByWithAggregationInput | CollegeOrderByWithAggregationInput[]
    by: CollegeScalarFieldEnum[] | CollegeScalarFieldEnum
    having?: CollegeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CollegeCountAggregateInputType | true
    _min?: CollegeMinAggregateInputType
    _max?: CollegeMaxAggregateInputType
  }

  export type CollegeGroupByOutputType = {
    id: string
    name: string
    _count: CollegeCountAggregateOutputType | null
    _min: CollegeMinAggregateOutputType | null
    _max: CollegeMaxAggregateOutputType | null
  }

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


  export type CollegeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    electedMembers?: boolean | College$electedMembersArgs<ExtArgs>
    user?: boolean | College$userArgs<ExtArgs>
    _count?: boolean | CollegeCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["college"]>

  export type CollegeSelectScalar = {
    id?: boolean
    name?: boolean
  }


  export type CollegeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    electedMembers?: boolean | College$electedMembersArgs<ExtArgs>
    user?: boolean | College$userArgs<ExtArgs>
    _count?: boolean | CollegeCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $CollegePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "College"
    objects: {
      electedMembers: Prisma.$ElectedMemberPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["college"]>
    composites: {}
  }


  type CollegeGetPayload<S extends boolean | null | undefined | CollegeDefaultArgs> = $Result.GetResult<Prisma.$CollegePayload, S>

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

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

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

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

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

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

    /**
     * Create a College.
     * @param {CollegeCreateArgs} args - Arguments to create a College.
     * @example
     * // Create one College
     * const College = await prisma.college.create({
     *   data: {
     *     // ... data to create a College
     *   }
     * })
     * 
    **/
    create<T extends CollegeCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CollegeCreateArgs<ExtArgs>>
    ): Prisma__CollegeClient<$Result.GetResult<Prisma.$CollegePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a College.
     * @param {CollegeDeleteArgs} args - Arguments to delete one College.
     * @example
     * // Delete one College
     * const College = await prisma.college.delete({
     *   where: {
     *     // ... filter to delete one College
     *   }
     * })
     * 
    **/
    delete<T extends CollegeDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CollegeDeleteArgs<ExtArgs>>
    ): Prisma__CollegeClient<$Result.GetResult<Prisma.$CollegePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one College.
     * @param {CollegeUpdateArgs} args - Arguments to update one College.
     * @example
     * // Update one College
     * const college = await prisma.college.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CollegeUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CollegeUpdateArgs<ExtArgs>>
    ): Prisma__CollegeClient<$Result.GetResult<Prisma.$CollegePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for College.
   * 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__CollegeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    electedMembers<T extends College$electedMembersArgs<ExtArgs> = {}>(args?: Subset<T, College$electedMembersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'findMany'> | Null>;

    user<T extends College$userArgs<ExtArgs> = {}>(args?: Subset<T, College$userArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<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 College model
   */ 
  interface CollegeFieldRefs {
    readonly id: FieldRef<"College", 'String'>
    readonly name: FieldRef<"College", 'String'>
  }
    

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

  /**
   * College findUniqueOrThrow
   */
  export type CollegeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    /**
     * Filter, which College to fetch.
     */
    where: CollegeWhereUniqueInput
  }

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

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

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

  /**
   * College create
   */
  export type CollegeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    /**
     * The data needed to create a College.
     */
    data: XOR<CollegeCreateInput, CollegeUncheckedCreateInput>
  }

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

  /**
   * College update
   */
  export type CollegeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    /**
     * The data needed to update a College.
     */
    data: XOR<CollegeUpdateInput, CollegeUncheckedUpdateInput>
    /**
     * Choose, which College to update.
     */
    where: CollegeWhereUniqueInput
  }

  /**
   * College updateMany
   */
  export type CollegeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Colleges.
     */
    data: XOR<CollegeUpdateManyMutationInput, CollegeUncheckedUpdateManyInput>
    /**
     * Filter which Colleges to update
     */
    where?: CollegeWhereInput
  }

  /**
   * College upsert
   */
  export type CollegeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    /**
     * The filter to search for the College to update in case it exists.
     */
    where: CollegeWhereUniqueInput
    /**
     * In case the College found by the `where` argument doesn't exist, create a new College with this data.
     */
    create: XOR<CollegeCreateInput, CollegeUncheckedCreateInput>
    /**
     * In case the College was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CollegeUpdateInput, CollegeUncheckedUpdateInput>
  }

  /**
   * College delete
   */
  export type CollegeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    /**
     * Filter which College to delete.
     */
    where: CollegeWhereUniqueInput
  }

  /**
   * College deleteMany
   */
  export type CollegeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Colleges to delete
     */
    where?: CollegeWhereInput
  }

  /**
   * College.electedMembers
   */
  export type College$electedMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithRelationInput | ElectedMemberOrderByWithRelationInput[]
    cursor?: ElectedMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ElectedMemberScalarFieldEnum | ElectedMemberScalarFieldEnum[]
  }

  /**
   * College.user
   */
  export type College$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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


  /**
   * Model ElectedMember
   */

  export type AggregateElectedMember = {
    _count: ElectedMemberCountAggregateOutputType | null
    _min: ElectedMemberMinAggregateOutputType | null
    _max: ElectedMemberMaxAggregateOutputType | null
  }

  export type ElectedMemberMinAggregateOutputType = {
    id: string | null
    image: string | null
    fullName: string | null
    positionId: string | null
    activityFamilyId: string | null
    activityId: string | null
    phoneNumber: string | null
    gsm: string | null
    fax: string | null
    email: string | null
    adresse: string | null
    collegeId: string | null
    provinceId: string | null
    mandateId: string | null
    details: string | null
  }

  export type ElectedMemberMaxAggregateOutputType = {
    id: string | null
    image: string | null
    fullName: string | null
    positionId: string | null
    activityFamilyId: string | null
    activityId: string | null
    phoneNumber: string | null
    gsm: string | null
    fax: string | null
    email: string | null
    adresse: string | null
    collegeId: string | null
    provinceId: string | null
    mandateId: string | null
    details: string | null
  }

  export type ElectedMemberCountAggregateOutputType = {
    id: number
    image: number
    fullName: number
    positionId: number
    activityFamilyId: number
    activityId: number
    phoneNumber: number
    gsm: number
    fax: number
    email: number
    adresse: number
    collegeId: number
    provinceId: number
    mandateId: number
    commissions: number
    details: number
    _all: number
  }


  export type ElectedMemberMinAggregateInputType = {
    id?: true
    image?: true
    fullName?: true
    positionId?: true
    activityFamilyId?: true
    activityId?: true
    phoneNumber?: true
    gsm?: true
    fax?: true
    email?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    details?: true
  }

  export type ElectedMemberMaxAggregateInputType = {
    id?: true
    image?: true
    fullName?: true
    positionId?: true
    activityFamilyId?: true
    activityId?: true
    phoneNumber?: true
    gsm?: true
    fax?: true
    email?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    details?: true
  }

  export type ElectedMemberCountAggregateInputType = {
    id?: true
    image?: true
    fullName?: true
    positionId?: true
    activityFamilyId?: true
    activityId?: true
    phoneNumber?: true
    gsm?: true
    fax?: true
    email?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    commissions?: true
    details?: true
    _all?: true
  }

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

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




  export type ElectedMemberGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ElectedMemberWhereInput
    orderBy?: ElectedMemberOrderByWithAggregationInput | ElectedMemberOrderByWithAggregationInput[]
    by: ElectedMemberScalarFieldEnum[] | ElectedMemberScalarFieldEnum
    having?: ElectedMemberScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ElectedMemberCountAggregateInputType | true
    _min?: ElectedMemberMinAggregateInputType
    _max?: ElectedMemberMaxAggregateInputType
  }

  export type ElectedMemberGroupByOutputType = {
    id: string
    image: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions: string[]
    details: string
    _count: ElectedMemberCountAggregateOutputType | null
    _min: ElectedMemberMinAggregateOutputType | null
    _max: ElectedMemberMaxAggregateOutputType | null
  }

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


  export type ElectedMemberSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    fullName?: boolean
    positionId?: boolean
    activityFamilyId?: boolean
    activityId?: boolean
    phoneNumber?: boolean
    gsm?: boolean
    fax?: boolean
    email?: boolean
    adresse?: boolean
    collegeId?: boolean
    provinceId?: boolean
    mandateId?: boolean
    commissions?: boolean
    details?: boolean
    position?: boolean | PositionDefaultArgs<ExtArgs>
    activityFamily?: boolean | ActivityFamilyDefaultArgs<ExtArgs>
    activity?: boolean | ActivityDefaultArgs<ExtArgs>
    college?: boolean | CollegeDefaultArgs<ExtArgs>
    province?: boolean | ProvinceDefaultArgs<ExtArgs>
    mandate?: boolean | MandateDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["electedMember"]>

  export type ElectedMemberSelectScalar = {
    id?: boolean
    image?: boolean
    fullName?: boolean
    positionId?: boolean
    activityFamilyId?: boolean
    activityId?: boolean
    phoneNumber?: boolean
    gsm?: boolean
    fax?: boolean
    email?: boolean
    adresse?: boolean
    collegeId?: boolean
    provinceId?: boolean
    mandateId?: boolean
    commissions?: boolean
    details?: boolean
  }


  export type ElectedMemberInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    position?: boolean | PositionDefaultArgs<ExtArgs>
    activityFamily?: boolean | ActivityFamilyDefaultArgs<ExtArgs>
    activity?: boolean | ActivityDefaultArgs<ExtArgs>
    college?: boolean | CollegeDefaultArgs<ExtArgs>
    province?: boolean | ProvinceDefaultArgs<ExtArgs>
    mandate?: boolean | MandateDefaultArgs<ExtArgs>
  }


  export type $ElectedMemberPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ElectedMember"
    objects: {
      position: Prisma.$PositionPayload<ExtArgs>
      activityFamily: Prisma.$ActivityFamilyPayload<ExtArgs>
      activity: Prisma.$ActivityPayload<ExtArgs>
      college: Prisma.$CollegePayload<ExtArgs>
      province: Prisma.$ProvincePayload<ExtArgs>
      mandate: Prisma.$MandatePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      image: string | null
      fullName: string
      positionId: string
      activityFamilyId: string
      activityId: string
      phoneNumber: string
      gsm: string
      fax: string
      email: string
      adresse: string
      collegeId: string
      provinceId: string
      mandateId: string
      commissions: string[]
      details: string
    }, ExtArgs["result"]["electedMember"]>
    composites: {}
  }


  type ElectedMemberGetPayload<S extends boolean | null | undefined | ElectedMemberDefaultArgs> = $Result.GetResult<Prisma.$ElectedMemberPayload, S>

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

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

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

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

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

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

    /**
     * Create a ElectedMember.
     * @param {ElectedMemberCreateArgs} args - Arguments to create a ElectedMember.
     * @example
     * // Create one ElectedMember
     * const ElectedMember = await prisma.electedMember.create({
     *   data: {
     *     // ... data to create a ElectedMember
     *   }
     * })
     * 
    **/
    create<T extends ElectedMemberCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ElectedMemberCreateArgs<ExtArgs>>
    ): Prisma__ElectedMemberClient<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ElectedMember.
     * @param {ElectedMemberDeleteArgs} args - Arguments to delete one ElectedMember.
     * @example
     * // Delete one ElectedMember
     * const ElectedMember = await prisma.electedMember.delete({
     *   where: {
     *     // ... filter to delete one ElectedMember
     *   }
     * })
     * 
    **/
    delete<T extends ElectedMemberDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ElectedMemberDeleteArgs<ExtArgs>>
    ): Prisma__ElectedMemberClient<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one ElectedMember.
     * @param {ElectedMemberUpdateArgs} args - Arguments to update one ElectedMember.
     * @example
     * // Update one ElectedMember
     * const electedMember = await prisma.electedMember.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ElectedMemberUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ElectedMemberUpdateArgs<ExtArgs>>
    ): Prisma__ElectedMemberClient<$Result.GetResult<Prisma.$ElectedMemberPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ElectedMember.
   * 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__ElectedMemberClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    position<T extends PositionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PositionDefaultArgs<ExtArgs>>): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    activityFamily<T extends ActivityFamilyDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ActivityFamilyDefaultArgs<ExtArgs>>): Prisma__ActivityFamilyClient<$Result.GetResult<Prisma.$ActivityFamilyPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    activity<T extends ActivityDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ActivityDefaultArgs<ExtArgs>>): Prisma__ActivityClient<$Result.GetResult<Prisma.$ActivityPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    college<T extends CollegeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CollegeDefaultArgs<ExtArgs>>): Prisma__CollegeClient<$Result.GetResult<Prisma.$CollegePayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    province<T extends ProvinceDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProvinceDefaultArgs<ExtArgs>>): Prisma__ProvinceClient<$Result.GetResult<Prisma.$ProvincePayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    mandate<T extends MandateDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MandateDefaultArgs<ExtArgs>>): Prisma__MandateClient<$Result.GetResult<Prisma.$MandatePayload<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 ElectedMember model
   */ 
  interface ElectedMemberFieldRefs {
    readonly id: FieldRef<"ElectedMember", 'String'>
    readonly image: FieldRef<"ElectedMember", 'String'>
    readonly fullName: FieldRef<"ElectedMember", 'String'>
    readonly positionId: FieldRef<"ElectedMember", 'String'>
    readonly activityFamilyId: FieldRef<"ElectedMember", 'String'>
    readonly activityId: FieldRef<"ElectedMember", 'String'>
    readonly phoneNumber: FieldRef<"ElectedMember", 'String'>
    readonly gsm: FieldRef<"ElectedMember", 'String'>
    readonly fax: FieldRef<"ElectedMember", 'String'>
    readonly email: FieldRef<"ElectedMember", 'String'>
    readonly adresse: FieldRef<"ElectedMember", 'String'>
    readonly collegeId: FieldRef<"ElectedMember", 'String'>
    readonly provinceId: FieldRef<"ElectedMember", 'String'>
    readonly mandateId: FieldRef<"ElectedMember", 'String'>
    readonly commissions: FieldRef<"ElectedMember", 'String[]'>
    readonly details: FieldRef<"ElectedMember", 'String'>
  }
    

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

  /**
   * ElectedMember findUniqueOrThrow
   */
  export type ElectedMemberFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    /**
     * Filter, which ElectedMember to fetch.
     */
    where: ElectedMemberWhereUniqueInput
  }

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

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

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

  /**
   * ElectedMember create
   */
  export type ElectedMemberCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    /**
     * The data needed to create a ElectedMember.
     */
    data: XOR<ElectedMemberCreateInput, ElectedMemberUncheckedCreateInput>
  }

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

  /**
   * ElectedMember update
   */
  export type ElectedMemberUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    /**
     * The data needed to update a ElectedMember.
     */
    data: XOR<ElectedMemberUpdateInput, ElectedMemberUncheckedUpdateInput>
    /**
     * Choose, which ElectedMember to update.
     */
    where: ElectedMemberWhereUniqueInput
  }

  /**
   * ElectedMember updateMany
   */
  export type ElectedMemberUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ElectedMembers.
     */
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyInput>
    /**
     * Filter which ElectedMembers to update
     */
    where?: ElectedMemberWhereInput
  }

  /**
   * ElectedMember upsert
   */
  export type ElectedMemberUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    /**
     * The filter to search for the ElectedMember to update in case it exists.
     */
    where: ElectedMemberWhereUniqueInput
    /**
     * In case the ElectedMember found by the `where` argument doesn't exist, create a new ElectedMember with this data.
     */
    create: XOR<ElectedMemberCreateInput, ElectedMemberUncheckedCreateInput>
    /**
     * In case the ElectedMember was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ElectedMemberUpdateInput, ElectedMemberUncheckedUpdateInput>
  }

  /**
   * ElectedMember delete
   */
  export type ElectedMemberDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ElectedMember
     */
    select?: ElectedMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ElectedMemberInclude<ExtArgs> | null
    /**
     * Filter which ElectedMember to delete.
     */
    where: ElectedMemberWhereUniqueInput
  }

  /**
   * ElectedMember deleteMany
   */
  export type ElectedMemberDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ElectedMembers to delete
     */
    where?: ElectedMemberWhereInput
  }

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


  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    civility: $Enums.Civility | null
    firstName: string | null
    lastName: string | null
    email: string | null
    password: string | null
    cityId: string | null
    positionId: string | null
    phoneNumber: string | null
    bio: string | null
    companyId: string | null
    department: string | null
    service: string | null
    adresse: string | null
    collegeId: string | null
    provinceId: string | null
    mandateId: string | null
    details: string | null
    active: boolean | null
    member: boolean | null
    role: $Enums.Role | null
    resetPasswordCode: string | null
    resetPasswordAt: Date | null
    loggedInAt: Date | null
    createdAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    civility: $Enums.Civility | null
    firstName: string | null
    lastName: string | null
    email: string | null
    password: string | null
    cityId: string | null
    positionId: string | null
    phoneNumber: string | null
    bio: string | null
    companyId: string | null
    department: string | null
    service: string | null
    adresse: string | null
    collegeId: string | null
    provinceId: string | null
    mandateId: string | null
    details: string | null
    active: boolean | null
    member: boolean | null
    role: $Enums.Role | null
    resetPasswordCode: string | null
    resetPasswordAt: Date | null
    loggedInAt: Date | null
    createdAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    civility: number
    firstName: number
    lastName: number
    email: number
    password: number
    cityId: number
    positionId: number
    phoneNumber: number
    expertiseAreas: number
    interestAreas: number
    bio: number
    companyId: number
    department: number
    service: number
    adresse: number
    collegeId: number
    provinceId: number
    mandateId: number
    commissions: number
    details: number
    active: number
    member: number
    role: number
    permissions: number
    resetPasswordCode: number
    resetPasswordAt: number
    loggedInAt: number
    createdAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    civility?: true
    firstName?: true
    lastName?: true
    email?: true
    password?: true
    cityId?: true
    positionId?: true
    phoneNumber?: true
    bio?: true
    companyId?: true
    department?: true
    service?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    details?: true
    active?: true
    member?: true
    role?: true
    resetPasswordCode?: true
    resetPasswordAt?: true
    loggedInAt?: true
    createdAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    civility?: true
    firstName?: true
    lastName?: true
    email?: true
    password?: true
    cityId?: true
    positionId?: true
    phoneNumber?: true
    bio?: true
    companyId?: true
    department?: true
    service?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    details?: true
    active?: true
    member?: true
    role?: true
    resetPasswordCode?: true
    resetPasswordAt?: true
    loggedInAt?: true
    createdAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    civility?: true
    firstName?: true
    lastName?: true
    email?: true
    password?: true
    cityId?: true
    positionId?: true
    phoneNumber?: true
    expertiseAreas?: true
    interestAreas?: true
    bio?: true
    companyId?: true
    department?: true
    service?: true
    adresse?: true
    collegeId?: true
    provinceId?: true
    mandateId?: true
    commissions?: true
    details?: true
    active?: true
    member?: true
    role?: true
    permissions?: true
    resetPasswordCode?: true
    resetPasswordAt?: true
    loggedInAt?: true
    createdAt?: 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
    civility: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId: string | null
    positionId: string | null
    phoneNumber: string
    expertiseAreas: string[]
    interestAreas: string[]
    bio: string
    companyId: string | null
    department: string | null
    service: string | null
    adresse: string | null
    collegeId: string | null
    provinceId: string | null
    mandateId: string | null
    commissions: string[]
    details: string | null
    active: boolean
    member: boolean
    role: $Enums.Role
    permissions: $Enums.Permission[]
    resetPasswordCode: string | null
    resetPasswordAt: Date | null
    loggedInAt: Date | null
    createdAt: 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
    civility?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    password?: boolean
    cityId?: boolean
    positionId?: boolean
    phoneNumber?: boolean
    expertiseAreas?: boolean
    interestAreas?: boolean
    bio?: boolean
    companyId?: boolean
    department?: boolean
    service?: boolean
    adresse?: boolean
    collegeId?: boolean
    provinceId?: boolean
    mandateId?: boolean
    commissions?: boolean
    details?: boolean
    active?: boolean
    member?: boolean
    role?: boolean
    permissions?: boolean
    resetPasswordCode?: boolean
    resetPasswordAt?: boolean
    loggedInAt?: boolean
    createdAt?: boolean
    city?: boolean | User$cityArgs<ExtArgs>
    position?: boolean | User$positionArgs<ExtArgs>
    company?: boolean | User$companyArgs<ExtArgs>
    college?: boolean | User$collegeArgs<ExtArgs>
    province?: boolean | User$provinceArgs<ExtArgs>
    mandate?: boolean | User$mandateArgs<ExtArgs>
    connectionsSent?: boolean | User$connectionsSentArgs<ExtArgs>
    connectionsReceived?: boolean | User$connectionsReceivedArgs<ExtArgs>
    messagesSent?: boolean | User$messagesSentArgs<ExtArgs>
    messagesReceived?: boolean | User$messagesReceivedArgs<ExtArgs>
    opportunities?: boolean | User$opportunitiesArgs<ExtArgs>
    opportunityLikes?: boolean | User$opportunityLikesArgs<ExtArgs>
    opportunityComments?: boolean | User$opportunityCommentsArgs<ExtArgs>
    eventLikes?: boolean | User$eventLikesArgs<ExtArgs>
    eventComments?: boolean | User$eventCommentsArgs<ExtArgs>
    appointmentLikes?: boolean | User$appointmentLikesArgs<ExtArgs>
    appointmentComments?: boolean | User$appointmentCommentsArgs<ExtArgs>
    notifications?: boolean | User$notificationsArgs<ExtArgs>
    appointmentsRegistrations?: boolean | User$appointmentsRegistrationsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    civility?: boolean
    firstName?: boolean
    lastName?: boolean
    email?: boolean
    password?: boolean
    cityId?: boolean
    positionId?: boolean
    phoneNumber?: boolean
    expertiseAreas?: boolean
    interestAreas?: boolean
    bio?: boolean
    companyId?: boolean
    department?: boolean
    service?: boolean
    adresse?: boolean
    collegeId?: boolean
    provinceId?: boolean
    mandateId?: boolean
    commissions?: boolean
    details?: boolean
    active?: boolean
    member?: boolean
    role?: boolean
    permissions?: boolean
    resetPasswordCode?: boolean
    resetPasswordAt?: boolean
    loggedInAt?: boolean
    createdAt?: boolean
  }


  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | User$cityArgs<ExtArgs>
    position?: boolean | User$positionArgs<ExtArgs>
    company?: boolean | User$companyArgs<ExtArgs>
    college?: boolean | User$collegeArgs<ExtArgs>
    province?: boolean | User$provinceArgs<ExtArgs>
    mandate?: boolean | User$mandateArgs<ExtArgs>
    connectionsSent?: boolean | User$connectionsSentArgs<ExtArgs>
    connectionsReceived?: boolean | User$connectionsReceivedArgs<ExtArgs>
    messagesSent?: boolean | User$messagesSentArgs<ExtArgs>
    messagesReceived?: boolean | User$messagesReceivedArgs<ExtArgs>
    opportunities?: boolean | User$opportunitiesArgs<ExtArgs>
    opportunityLikes?: boolean | User$opportunityLikesArgs<ExtArgs>
    opportunityComments?: boolean | User$opportunityCommentsArgs<ExtArgs>
    eventLikes?: boolean | User$eventLikesArgs<ExtArgs>
    eventComments?: boolean | User$eventCommentsArgs<ExtArgs>
    appointmentLikes?: boolean | User$appointmentLikesArgs<ExtArgs>
    appointmentComments?: boolean | User$appointmentCommentsArgs<ExtArgs>
    notifications?: boolean | User$notificationsArgs<ExtArgs>
    appointmentsRegistrations?: boolean | User$appointmentsRegistrationsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      city: Prisma.$CityPayload<ExtArgs> | null
      position: Prisma.$PositionPayload<ExtArgs> | null
      company: Prisma.$CompanyPayload<ExtArgs> | null
      college: Prisma.$CollegePayload<ExtArgs> | null
      province: Prisma.$ProvincePayload<ExtArgs> | null
      mandate: Prisma.$MandatePayload<ExtArgs> | null
      connectionsSent: Prisma.$ConnectionPayload<ExtArgs>[]
      connectionsReceived: Prisma.$ConnectionPayload<ExtArgs>[]
      messagesSent: Prisma.$MessagePayload<ExtArgs>[]
      messagesReceived: Prisma.$MessagePayload<ExtArgs>[]
      opportunities: Prisma.$OpportunityPayload<ExtArgs>[]
      opportunityLikes: Prisma.$OpportunityLikePayload<ExtArgs>[]
      opportunityComments: Prisma.$OpportunityCommentPayload<ExtArgs>[]
      eventLikes: Prisma.$EventLikePayload<ExtArgs>[]
      eventComments: Prisma.$EventCommentPayload<ExtArgs>[]
      appointmentLikes: Prisma.$AppointmentLikePayload<ExtArgs>[]
      appointmentComments: Prisma.$AppointmentCommentPayload<ExtArgs>[]
      notifications: Prisma.$NotificationPayload<ExtArgs>[]
      appointmentsRegistrations: Prisma.$AppointmentRegistrationPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      civility: $Enums.Civility
      firstName: string
      lastName: string
      email: string
      password: string
      cityId: string | null
      positionId: string | null
      phoneNumber: string
      expertiseAreas: string[]
      interestAreas: string[]
      bio: string
      companyId: string | null
      department: string | null
      service: string | null
      adresse: string | null
      collegeId: string | null
      provinceId: string | null
      mandateId: string | null
      commissions: string[]
      details: string | null
      active: boolean
      member: boolean
      role: $Enums.Role
      permissions: $Enums.Permission[]
      resetPasswordCode: string | null
      resetPasswordAt: Date | null
      loggedInAt: Date | null
      createdAt: 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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      args?: SelectSubset<T, UserCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

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

    city<T extends User$cityArgs<ExtArgs> = {}>(args?: Subset<T, User$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    position<T extends User$positionArgs<ExtArgs> = {}>(args?: Subset<T, User$positionArgs<ExtArgs>>): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    company<T extends User$companyArgs<ExtArgs> = {}>(args?: Subset<T, User$companyArgs<ExtArgs>>): Prisma__CompanyClient<$Result.GetResult<Prisma.$CompanyPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    college<T extends User$collegeArgs<ExtArgs> = {}>(args?: Subset<T, User$collegeArgs<ExtArgs>>): Prisma__CollegeClient<$Result.GetResult<Prisma.$CollegePayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    province<T extends User$provinceArgs<ExtArgs> = {}>(args?: Subset<T, User$provinceArgs<ExtArgs>>): Prisma__ProvinceClient<$Result.GetResult<Prisma.$ProvincePayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    mandate<T extends User$mandateArgs<ExtArgs> = {}>(args?: Subset<T, User$mandateArgs<ExtArgs>>): Prisma__MandateClient<$Result.GetResult<Prisma.$MandatePayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    connectionsSent<T extends User$connectionsSentArgs<ExtArgs> = {}>(args?: Subset<T, User$connectionsSentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ConnectionPayload<ExtArgs>, T, 'findMany'> | Null>;

    connectionsReceived<T extends User$connectionsReceivedArgs<ExtArgs> = {}>(args?: Subset<T, User$connectionsReceivedArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ConnectionPayload<ExtArgs>, T, 'findMany'> | Null>;

    messagesSent<T extends User$messagesSentArgs<ExtArgs> = {}>(args?: Subset<T, User$messagesSentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MessagePayload<ExtArgs>, T, 'findMany'> | Null>;

    messagesReceived<T extends User$messagesReceivedArgs<ExtArgs> = {}>(args?: Subset<T, User$messagesReceivedArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MessagePayload<ExtArgs>, T, 'findMany'> | Null>;

    opportunities<T extends User$opportunitiesArgs<ExtArgs> = {}>(args?: Subset<T, User$opportunitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OpportunityPayload<ExtArgs>, T, 'findMany'> | Null>;

    opportunityLikes<T extends User$opportunityLikesArgs<ExtArgs> = {}>(args?: Subset<T, User$opportunityLikesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OpportunityLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    opportunityComments<T extends User$opportunityCommentsArgs<ExtArgs> = {}>(args?: Subset<T, User$opportunityCommentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OpportunityCommentPayload<ExtArgs>, T, 'findMany'> | Null>;

    eventLikes<T extends User$eventLikesArgs<ExtArgs> = {}>(args?: Subset<T, User$eventLikesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    eventComments<T extends User$eventCommentsArgs<ExtArgs> = {}>(args?: Subset<T, User$eventCommentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventCommentPayload<ExtArgs>, T, 'findMany'> | Null>;

    appointmentLikes<T extends User$appointmentLikesArgs<ExtArgs> = {}>(args?: Subset<T, User$appointmentLikesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    appointmentComments<T extends User$appointmentCommentsArgs<ExtArgs> = {}>(args?: Subset<T, User$appointmentCommentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentCommentPayload<ExtArgs>, T, 'findMany'> | Null>;

    notifications<T extends User$notificationsArgs<ExtArgs> = {}>(args?: Subset<T, User$notificationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, 'findMany'> | Null>;

    appointmentsRegistrations<T extends User$appointmentsRegistrationsArgs<ExtArgs> = {}>(args?: Subset<T, User$appointmentsRegistrationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentRegistrationPayload<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 civility: FieldRef<"User", 'Civility'>
    readonly firstName: FieldRef<"User", 'String'>
    readonly lastName: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly password: FieldRef<"User", 'String'>
    readonly cityId: FieldRef<"User", 'String'>
    readonly positionId: FieldRef<"User", 'String'>
    readonly phoneNumber: FieldRef<"User", 'String'>
    readonly expertiseAreas: FieldRef<"User", 'String[]'>
    readonly interestAreas: FieldRef<"User", 'String[]'>
    readonly bio: FieldRef<"User", 'String'>
    readonly companyId: FieldRef<"User", 'String'>
    readonly department: FieldRef<"User", 'String'>
    readonly service: FieldRef<"User", 'String'>
    readonly adresse: FieldRef<"User", 'String'>
    readonly collegeId: FieldRef<"User", 'String'>
    readonly provinceId: FieldRef<"User", 'String'>
    readonly mandateId: FieldRef<"User", 'String'>
    readonly commissions: FieldRef<"User", 'String[]'>
    readonly details: FieldRef<"User", 'String'>
    readonly active: FieldRef<"User", 'Boolean'>
    readonly member: FieldRef<"User", 'Boolean'>
    readonly role: FieldRef<"User", 'Role'>
    readonly permissions: FieldRef<"User", 'Permission[]'>
    readonly resetPasswordCode: FieldRef<"User", 'String'>
    readonly resetPasswordAt: FieldRef<"User", 'DateTime'>
    readonly loggedInAt: FieldRef<"User", 'DateTime'>
    readonly createdAt: 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 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.city
   */
  export type User$cityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    where?: CityWhereInput
  }

  /**
   * User.position
   */
  export type User$positionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    where?: PositionWhereInput
  }

  /**
   * User.company
   */
  export type User$companyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    where?: CompanyWhereInput
  }

  /**
   * User.college
   */
  export type User$collegeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the College
     */
    select?: CollegeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollegeInclude<ExtArgs> | null
    where?: CollegeWhereInput
  }

  /**
   * User.province
   */
  export type User$provinceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Province
     */
    select?: ProvinceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProvinceInclude<ExtArgs> | null
    where?: ProvinceWhereInput
  }

  /**
   * User.mandate
   */
  export type User$mandateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Mandate
     */
    select?: MandateSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MandateInclude<ExtArgs> | null
    where?: MandateWhereInput
  }

  /**
   * User.connectionsSent
   */
  export type User$connectionsSentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    where?: ConnectionWhereInput
    orderBy?: ConnectionOrderByWithRelationInput | ConnectionOrderByWithRelationInput[]
    cursor?: ConnectionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ConnectionScalarFieldEnum | ConnectionScalarFieldEnum[]
  }

  /**
   * User.connectionsReceived
   */
  export type User$connectionsReceivedArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    where?: ConnectionWhereInput
    orderBy?: ConnectionOrderByWithRelationInput | ConnectionOrderByWithRelationInput[]
    cursor?: ConnectionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ConnectionScalarFieldEnum | ConnectionScalarFieldEnum[]
  }

  /**
   * User.messagesSent
   */
  export type User$messagesSentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    where?: MessageWhereInput
    orderBy?: MessageOrderByWithRelationInput | MessageOrderByWithRelationInput[]
    cursor?: MessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessageScalarFieldEnum | MessageScalarFieldEnum[]
  }

  /**
   * User.messagesReceived
   */
  export type User$messagesReceivedArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    where?: MessageWhereInput
    orderBy?: MessageOrderByWithRelationInput | MessageOrderByWithRelationInput[]
    cursor?: MessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MessageScalarFieldEnum | MessageScalarFieldEnum[]
  }

  /**
   * User.opportunities
   */
  export type User$opportunitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    where?: OpportunityWhereInput
    orderBy?: OpportunityOrderByWithRelationInput | OpportunityOrderByWithRelationInput[]
    cursor?: OpportunityWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OpportunityScalarFieldEnum | OpportunityScalarFieldEnum[]
  }

  /**
   * User.opportunityLikes
   */
  export type User$opportunityLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    where?: OpportunityLikeWhereInput
    orderBy?: OpportunityLikeOrderByWithRelationInput | OpportunityLikeOrderByWithRelationInput[]
    cursor?: OpportunityLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OpportunityLikeScalarFieldEnum | OpportunityLikeScalarFieldEnum[]
  }

  /**
   * User.opportunityComments
   */
  export type User$opportunityCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    where?: OpportunityCommentWhereInput
    orderBy?: OpportunityCommentOrderByWithRelationInput | OpportunityCommentOrderByWithRelationInput[]
    cursor?: OpportunityCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OpportunityCommentScalarFieldEnum | OpportunityCommentScalarFieldEnum[]
  }

  /**
   * User.eventLikes
   */
  export type User$eventLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    where?: EventLikeWhereInput
    orderBy?: EventLikeOrderByWithRelationInput | EventLikeOrderByWithRelationInput[]
    cursor?: EventLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventLikeScalarFieldEnum | EventLikeScalarFieldEnum[]
  }

  /**
   * User.eventComments
   */
  export type User$eventCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    where?: EventCommentWhereInput
    orderBy?: EventCommentOrderByWithRelationInput | EventCommentOrderByWithRelationInput[]
    cursor?: EventCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventCommentScalarFieldEnum | EventCommentScalarFieldEnum[]
  }

  /**
   * User.appointmentLikes
   */
  export type User$appointmentLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    where?: AppointmentLikeWhereInput
    orderBy?: AppointmentLikeOrderByWithRelationInput | AppointmentLikeOrderByWithRelationInput[]
    cursor?: AppointmentLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentLikeScalarFieldEnum | AppointmentLikeScalarFieldEnum[]
  }

  /**
   * User.appointmentComments
   */
  export type User$appointmentCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    where?: AppointmentCommentWhereInput
    orderBy?: AppointmentCommentOrderByWithRelationInput | AppointmentCommentOrderByWithRelationInput[]
    cursor?: AppointmentCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentCommentScalarFieldEnum | AppointmentCommentScalarFieldEnum[]
  }

  /**
   * User.notifications
   */
  export type User$notificationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    cursor?: NotificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * User.appointmentsRegistrations
   */
  export type User$appointmentsRegistrationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    where?: AppointmentRegistrationWhereInput
    orderBy?: AppointmentRegistrationOrderByWithRelationInput | AppointmentRegistrationOrderByWithRelationInput[]
    cursor?: AppointmentRegistrationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentRegistrationScalarFieldEnum | AppointmentRegistrationScalarFieldEnum[]
  }

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

  export type AggregateNotification = {
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  export type NotificationMinAggregateOutputType = {
    id: string | null
    title: string | null
    content: string | null
    source: $Enums.Source | null
    createdAt: Date | null
    isRead: boolean | null
    userId: string | null
  }

  export type NotificationMaxAggregateOutputType = {
    id: string | null
    title: string | null
    content: string | null
    source: $Enums.Source | null
    createdAt: Date | null
    isRead: boolean | null
    userId: string | null
  }

  export type NotificationCountAggregateOutputType = {
    id: number
    title: number
    content: number
    source: number
    createdAt: number
    isRead: number
    userId: number
    _all: number
  }


  export type NotificationMinAggregateInputType = {
    id?: true
    title?: true
    content?: true
    source?: true
    createdAt?: true
    isRead?: true
    userId?: true
  }

  export type NotificationMaxAggregateInputType = {
    id?: true
    title?: true
    content?: true
    source?: true
    createdAt?: true
    isRead?: true
    userId?: true
  }

  export type NotificationCountAggregateInputType = {
    id?: true
    title?: true
    content?: true
    source?: true
    createdAt?: true
    isRead?: true
    userId?: true
    _all?: true
  }

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

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




  export type NotificationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithAggregationInput | NotificationOrderByWithAggregationInput[]
    by: NotificationScalarFieldEnum[] | NotificationScalarFieldEnum
    having?: NotificationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NotificationCountAggregateInputType | true
    _min?: NotificationMinAggregateInputType
    _max?: NotificationMaxAggregateInputType
  }

  export type NotificationGroupByOutputType = {
    id: string
    title: string
    content: string
    source: $Enums.Source
    createdAt: Date
    isRead: boolean
    userId: string
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

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


  export type NotificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    content?: boolean
    source?: boolean
    createdAt?: boolean
    isRead?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectScalar = {
    id?: boolean
    title?: boolean
    content?: boolean
    source?: boolean
    createdAt?: boolean
    isRead?: boolean
    userId?: boolean
  }


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


  export type $NotificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Notification"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      content: string
      source: $Enums.Source
      createdAt: Date
      isRead: boolean
      userId: string
    }, ExtArgs["result"]["notification"]>
    composites: {}
  }


  type NotificationGetPayload<S extends boolean | null | undefined | NotificationDefaultArgs> = $Result.GetResult<Prisma.$NotificationPayload, S>

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

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

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

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

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

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

    /**
     * Create a Notification.
     * @param {NotificationCreateArgs} args - Arguments to create a Notification.
     * @example
     * // Create one Notification
     * const Notification = await prisma.notification.create({
     *   data: {
     *     // ... data to create a Notification
     *   }
     * })
     * 
    **/
    create<T extends NotificationCreateArgs<ExtArgs>>(
      args: SelectSubset<T, NotificationCreateArgs<ExtArgs>>
    ): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Notification.
     * @param {NotificationDeleteArgs} args - Arguments to delete one Notification.
     * @example
     * // Delete one Notification
     * const Notification = await prisma.notification.delete({
     *   where: {
     *     // ... filter to delete one Notification
     *   }
     * })
     * 
    **/
    delete<T extends NotificationDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, NotificationDeleteArgs<ExtArgs>>
    ): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Notification.
     * @param {NotificationUpdateArgs} args - Arguments to update one Notification.
     * @example
     * // Update one Notification
     * const notification = await prisma.notification.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends NotificationUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, NotificationUpdateArgs<ExtArgs>>
    ): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Notification.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__NotificationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>;
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>;
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>;
  }



  /**
   * Fields of the Notification model
   */ 
  interface NotificationFieldRefs {
    readonly id: FieldRef<"Notification", 'String'>
    readonly title: FieldRef<"Notification", 'String'>
    readonly content: FieldRef<"Notification", 'String'>
    readonly source: FieldRef<"Notification", 'Source'>
    readonly createdAt: FieldRef<"Notification", 'DateTime'>
    readonly isRead: FieldRef<"Notification", 'Boolean'>
    readonly userId: FieldRef<"Notification", 'String'>
  }
    

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

  /**
   * Notification findUniqueOrThrow
   */
  export type NotificationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where: NotificationWhereUniqueInput
  }

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

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

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

  /**
   * Notification create
   */
  export type NotificationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to create a Notification.
     */
    data: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
  }

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

  /**
   * Notification update
   */
  export type NotificationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to update a Notification.
     */
    data: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
    /**
     * Choose, which Notification to update.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification updateMany
   */
  export type NotificationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Notifications.
     */
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyInput>
    /**
     * Filter which Notifications to update
     */
    where?: NotificationWhereInput
  }

  /**
   * Notification upsert
   */
  export type NotificationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The filter to search for the Notification to update in case it exists.
     */
    where: NotificationWhereUniqueInput
    /**
     * In case the Notification found by the `where` argument doesn't exist, create a new Notification with this data.
     */
    create: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
    /**
     * In case the Notification was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
  }

  /**
   * Notification delete
   */
  export type NotificationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter which Notification to delete.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification deleteMany
   */
  export type NotificationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Notifications to delete
     */
    where?: NotificationWhereInput
  }

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


  /**
   * Model Company
   */

  export type AggregateCompany = {
    _count: CompanyCountAggregateOutputType | null
    _avg: CompanyAvgAggregateOutputType | null
    _sum: CompanySumAggregateOutputType | null
    _min: CompanyMinAggregateOutputType | null
    _max: CompanyMaxAggregateOutputType | null
  }

  export type CompanyAvgAggregateOutputType = {
    capital: number | null
  }

  export type CompanySumAggregateOutputType = {
    capital: number | null
  }

  export type CompanyMinAggregateOutputType = {
    id: string | null
    logo: string | null
    name: string | null
    legalForm: $Enums.LegalForm | null
    cityId: string | null
    address: string | null
    phoneNumber: string | null
    fax: string | null
    email: string | null
    website: string | null
    linkedin: string | null
    facebook: string | null
    contactFirstName: string | null
    contactLastName: string | null
    contactEmail: string | null
    contactPositionId: string | null
    contactLinkedin: string | null
    contactFacebook: string | null
    businessLicense: string | null
    numRC: string | null
    numICE: string | null
    capital: number | null
    turnoverId: string | null
    nEmployeesId: string | null
    verified: boolean | null
    active: boolean | null
    partner: boolean | null
    contributor: boolean | null
    createdAt: Date | null
  }

  export type CompanyMaxAggregateOutputType = {
    id: string | null
    logo: string | null
    name: string | null
    legalForm: $Enums.LegalForm | null
    cityId: string | null
    address: string | null
    phoneNumber: string | null
    fax: string | null
    email: string | null
    website: string | null
    linkedin: string | null
    facebook: string | null
    contactFirstName: string | null
    contactLastName: string | null
    contactEmail: string | null
    contactPositionId: string | null
    contactLinkedin: string | null
    contactFacebook: string | null
    businessLicense: string | null
    numRC: string | null
    numICE: string | null
    capital: number | null
    turnoverId: string | null
    nEmployeesId: string | null
    verified: boolean | null
    active: boolean | null
    partner: boolean | null
    contributor: boolean | null
    createdAt: Date | null
  }

  export type CompanyCountAggregateOutputType = {
    id: number
    logo: number
    name: number
    legalForm: number
    cityId: number
    address: number
    phoneNumber: number
    fax: number
    email: number
    website: number
    linkedin: number
    facebook: number
    contactFirstName: number
    contactLastName: number
    contactEmail: number
    contactPositionId: number
    contactLinkedin: number
    contactFacebook: number
    businessLicense: number
    numRC: number
    numICE: number
    capital: number
    turnoverId: number
    nEmployeesId: number
    activitiesFamilies: number
    activities: number
    importCountries: number
    exportCountries: number
    verified: number
    active: number
    partner: number
    contributor: number
    createdAt: number
    _all: number
  }


  export type CompanyAvgAggregateInputType = {
    capital?: true
  }

  export type CompanySumAggregateInputType = {
    capital?: true
  }

  export type CompanyMinAggregateInputType = {
    id?: true
    logo?: true
    name?: true
    legalForm?: true
    cityId?: true
    address?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
    linkedin?: true
    facebook?: true
    contactFirstName?: true
    contactLastName?: true
    contactEmail?: true
    contactPositionId?: true
    contactLinkedin?: true
    contactFacebook?: true
    businessLicense?: true
    numRC?: true
    numICE?: true
    capital?: true
    turnoverId?: true
    nEmployeesId?: true
    verified?: true
    active?: true
    partner?: true
    contributor?: true
    createdAt?: true
  }

  export type CompanyMaxAggregateInputType = {
    id?: true
    logo?: true
    name?: true
    legalForm?: true
    cityId?: true
    address?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
    linkedin?: true
    facebook?: true
    contactFirstName?: true
    contactLastName?: true
    contactEmail?: true
    contactPositionId?: true
    contactLinkedin?: true
    contactFacebook?: true
    businessLicense?: true
    numRC?: true
    numICE?: true
    capital?: true
    turnoverId?: true
    nEmployeesId?: true
    verified?: true
    active?: true
    partner?: true
    contributor?: true
    createdAt?: true
  }

  export type CompanyCountAggregateInputType = {
    id?: true
    logo?: true
    name?: true
    legalForm?: true
    cityId?: true
    address?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
    linkedin?: true
    facebook?: true
    contactFirstName?: true
    contactLastName?: true
    contactEmail?: true
    contactPositionId?: true
    contactLinkedin?: true
    contactFacebook?: true
    businessLicense?: true
    numRC?: true
    numICE?: true
    capital?: true
    turnoverId?: true
    nEmployeesId?: true
    activitiesFamilies?: true
    activities?: true
    importCountries?: true
    exportCountries?: true
    verified?: true
    active?: true
    partner?: true
    contributor?: true
    createdAt?: true
    _all?: true
  }

  export type CompanyAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Company to aggregate.
     */
    where?: CompanyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Companies to fetch.
     */
    orderBy?: CompanyOrderByWithRelationInput | CompanyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CompanyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Companies from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Companies.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Companies
    **/
    _count?: true | CompanyCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CompanyAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CompanySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CompanyMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CompanyMaxAggregateInputType
  }

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




  export type CompanyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CompanyWhereInput
    orderBy?: CompanyOrderByWithAggregationInput | CompanyOrderByWithAggregationInput[]
    by: CompanyScalarFieldEnum[] | CompanyScalarFieldEnum
    having?: CompanyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CompanyCountAggregateInputType | true
    _avg?: CompanyAvgAggregateInputType
    _sum?: CompanySumAggregateInputType
    _min?: CompanyMinAggregateInputType
    _max?: CompanyMaxAggregateInputType
  }

  export type CompanyGroupByOutputType = {
    id: string
    logo: string | null
    name: string
    legalForm: $Enums.LegalForm
    cityId: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital: number | null
    turnoverId: string | null
    nEmployeesId: string | null
    activitiesFamilies: string[]
    activities: string[]
    importCountries: string[]
    exportCountries: string[]
    verified: boolean
    active: boolean
    partner: boolean
    contributor: boolean
    createdAt: Date
    _count: CompanyCountAggregateOutputType | null
    _avg: CompanyAvgAggregateOutputType | null
    _sum: CompanySumAggregateOutputType | null
    _min: CompanyMinAggregateOutputType | null
    _max: CompanyMaxAggregateOutputType | null
  }

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


  export type CompanySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    logo?: boolean
    name?: boolean
    legalForm?: boolean
    cityId?: boolean
    address?: boolean
    phoneNumber?: boolean
    fax?: boolean
    email?: boolean
    website?: boolean
    linkedin?: boolean
    facebook?: boolean
    contactFirstName?: boolean
    contactLastName?: boolean
    contactEmail?: boolean
    contactPositionId?: boolean
    contactLinkedin?: boolean
    contactFacebook?: boolean
    businessLicense?: boolean
    numRC?: boolean
    numICE?: boolean
    capital?: boolean
    turnoverId?: boolean
    nEmployeesId?: boolean
    activitiesFamilies?: boolean
    activities?: boolean
    importCountries?: boolean
    exportCountries?: boolean
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: boolean
    city?: boolean | Company$cityArgs<ExtArgs>
    contactPosition?: boolean | Company$contactPositionArgs<ExtArgs>
    turnover?: boolean | Company$turnoverArgs<ExtArgs>
    nEmployees?: boolean | Company$nEmployeesArgs<ExtArgs>
    users?: boolean | Company$usersArgs<ExtArgs>
    _count?: boolean | CompanyCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["company"]>

  export type CompanySelectScalar = {
    id?: boolean
    logo?: boolean
    name?: boolean
    legalForm?: boolean
    cityId?: boolean
    address?: boolean
    phoneNumber?: boolean
    fax?: boolean
    email?: boolean
    website?: boolean
    linkedin?: boolean
    facebook?: boolean
    contactFirstName?: boolean
    contactLastName?: boolean
    contactEmail?: boolean
    contactPositionId?: boolean
    contactLinkedin?: boolean
    contactFacebook?: boolean
    businessLicense?: boolean
    numRC?: boolean
    numICE?: boolean
    capital?: boolean
    turnoverId?: boolean
    nEmployeesId?: boolean
    activitiesFamilies?: boolean
    activities?: boolean
    importCountries?: boolean
    exportCountries?: boolean
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: boolean
  }


  export type CompanyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | Company$cityArgs<ExtArgs>
    contactPosition?: boolean | Company$contactPositionArgs<ExtArgs>
    turnover?: boolean | Company$turnoverArgs<ExtArgs>
    nEmployees?: boolean | Company$nEmployeesArgs<ExtArgs>
    users?: boolean | Company$usersArgs<ExtArgs>
    _count?: boolean | CompanyCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $CompanyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Company"
    objects: {
      city: Prisma.$CityPayload<ExtArgs> | null
      contactPosition: Prisma.$PositionPayload<ExtArgs> | null
      turnover: Prisma.$TurnoverPayload<ExtArgs> | null
      nEmployees: Prisma.$NEmployeesPayload<ExtArgs> | null
      users: Prisma.$UserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      logo: string | null
      name: string
      legalForm: $Enums.LegalForm
      cityId: string | null
      address: string
      phoneNumber: string
      fax: string
      email: string
      website: string
      linkedin: string
      facebook: string
      contactFirstName: string
      contactLastName: string
      contactEmail: string
      contactPositionId: string | null
      contactLinkedin: string
      contactFacebook: string
      businessLicense: string
      numRC: string
      numICE: string
      capital: number | null
      turnoverId: string | null
      nEmployeesId: string | null
      activitiesFamilies: string[]
      activities: string[]
      importCountries: string[]
      exportCountries: string[]
      verified: boolean
      active: boolean
      partner: boolean
      contributor: boolean
      createdAt: Date
    }, ExtArgs["result"]["company"]>
    composites: {}
  }


  type CompanyGetPayload<S extends boolean | null | undefined | CompanyDefaultArgs> = $Result.GetResult<Prisma.$CompanyPayload, S>

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

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

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

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

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

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

    /**
     * Create a Company.
     * @param {CompanyCreateArgs} args - Arguments to create a Company.
     * @example
     * // Create one Company
     * const Company = await prisma.company.create({
     *   data: {
     *     // ... data to create a Company
     *   }
     * })
     * 
    **/
    create<T extends CompanyCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CompanyCreateArgs<ExtArgs>>
    ): Prisma__CompanyClient<$Result.GetResult<Prisma.$CompanyPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Company.
     * @param {CompanyDeleteArgs} args - Arguments to delete one Company.
     * @example
     * // Delete one Company
     * const Company = await prisma.company.delete({
     *   where: {
     *     // ... filter to delete one Company
     *   }
     * })
     * 
    **/
    delete<T extends CompanyDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CompanyDeleteArgs<ExtArgs>>
    ): Prisma__CompanyClient<$Result.GetResult<Prisma.$CompanyPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Company.
     * @param {CompanyUpdateArgs} args - Arguments to update one Company.
     * @example
     * // Update one Company
     * const company = await prisma.company.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CompanyUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CompanyUpdateArgs<ExtArgs>>
    ): Prisma__CompanyClient<$Result.GetResult<Prisma.$CompanyPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Company.
   * 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__CompanyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    city<T extends Company$cityArgs<ExtArgs> = {}>(args?: Subset<T, Company$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    contactPosition<T extends Company$contactPositionArgs<ExtArgs> = {}>(args?: Subset<T, Company$contactPositionArgs<ExtArgs>>): Prisma__PositionClient<$Result.GetResult<Prisma.$PositionPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    turnover<T extends Company$turnoverArgs<ExtArgs> = {}>(args?: Subset<T, Company$turnoverArgs<ExtArgs>>): Prisma__TurnoverClient<$Result.GetResult<Prisma.$TurnoverPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    nEmployees<T extends Company$nEmployeesArgs<ExtArgs> = {}>(args?: Subset<T, Company$nEmployeesArgs<ExtArgs>>): Prisma__NEmployeesClient<$Result.GetResult<Prisma.$NEmployeesPayload<ExtArgs>, T, 'findUniqueOrThrow'> | null, null, ExtArgs>;

    users<T extends Company$usersArgs<ExtArgs> = {}>(args?: Subset<T, Company$usersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<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 Company model
   */ 
  interface CompanyFieldRefs {
    readonly id: FieldRef<"Company", 'String'>
    readonly logo: FieldRef<"Company", 'String'>
    readonly name: FieldRef<"Company", 'String'>
    readonly legalForm: FieldRef<"Company", 'LegalForm'>
    readonly cityId: FieldRef<"Company", 'String'>
    readonly address: FieldRef<"Company", 'String'>
    readonly phoneNumber: FieldRef<"Company", 'String'>
    readonly fax: FieldRef<"Company", 'String'>
    readonly email: FieldRef<"Company", 'String'>
    readonly website: FieldRef<"Company", 'String'>
    readonly linkedin: FieldRef<"Company", 'String'>
    readonly facebook: FieldRef<"Company", 'String'>
    readonly contactFirstName: FieldRef<"Company", 'String'>
    readonly contactLastName: FieldRef<"Company", 'String'>
    readonly contactEmail: FieldRef<"Company", 'String'>
    readonly contactPositionId: FieldRef<"Company", 'String'>
    readonly contactLinkedin: FieldRef<"Company", 'String'>
    readonly contactFacebook: FieldRef<"Company", 'String'>
    readonly businessLicense: FieldRef<"Company", 'String'>
    readonly numRC: FieldRef<"Company", 'String'>
    readonly numICE: FieldRef<"Company", 'String'>
    readonly capital: FieldRef<"Company", 'Float'>
    readonly turnoverId: FieldRef<"Company", 'String'>
    readonly nEmployeesId: FieldRef<"Company", 'String'>
    readonly activitiesFamilies: FieldRef<"Company", 'String[]'>
    readonly activities: FieldRef<"Company", 'String[]'>
    readonly importCountries: FieldRef<"Company", 'String[]'>
    readonly exportCountries: FieldRef<"Company", 'String[]'>
    readonly verified: FieldRef<"Company", 'Boolean'>
    readonly active: FieldRef<"Company", 'Boolean'>
    readonly partner: FieldRef<"Company", 'Boolean'>
    readonly contributor: FieldRef<"Company", 'Boolean'>
    readonly createdAt: FieldRef<"Company", 'DateTime'>
  }
    

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

  /**
   * Company findUniqueOrThrow
   */
  export type CompanyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    /**
     * Filter, which Company to fetch.
     */
    where: CompanyWhereUniqueInput
  }

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

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

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

  /**
   * Company create
   */
  export type CompanyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    /**
     * The data needed to create a Company.
     */
    data: XOR<CompanyCreateInput, CompanyUncheckedCreateInput>
  }

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

  /**
   * Company update
   */
  export type CompanyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    /**
     * The data needed to update a Company.
     */
    data: XOR<CompanyUpdateInput, CompanyUncheckedUpdateInput>
    /**
     * Choose, which Company to update.
     */
    where: CompanyWhereUniqueInput
  }

  /**
   * Company updateMany
   */
  export type CompanyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Companies.
     */
    data: XOR<CompanyUpdateManyMutationInput, CompanyUncheckedUpdateManyInput>
    /**
     * Filter which Companies to update
     */
    where?: CompanyWhereInput
  }

  /**
   * Company upsert
   */
  export type CompanyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    /**
     * The filter to search for the Company to update in case it exists.
     */
    where: CompanyWhereUniqueInput
    /**
     * In case the Company found by the `where` argument doesn't exist, create a new Company with this data.
     */
    create: XOR<CompanyCreateInput, CompanyUncheckedCreateInput>
    /**
     * In case the Company was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CompanyUpdateInput, CompanyUncheckedUpdateInput>
  }

  /**
   * Company delete
   */
  export type CompanyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Company
     */
    select?: CompanySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CompanyInclude<ExtArgs> | null
    /**
     * Filter which Company to delete.
     */
    where: CompanyWhereUniqueInput
  }

  /**
   * Company deleteMany
   */
  export type CompanyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Companies to delete
     */
    where?: CompanyWhereInput
  }

  /**
   * Company.city
   */
  export type Company$cityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CityInclude<ExtArgs> | null
    where?: CityWhereInput
  }

  /**
   * Company.contactPosition
   */
  export type Company$contactPositionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Position
     */
    select?: PositionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PositionInclude<ExtArgs> | null
    where?: PositionWhereInput
  }

  /**
   * Company.turnover
   */
  export type Company$turnoverArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Turnover
     */
    select?: TurnoverSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TurnoverInclude<ExtArgs> | null
    where?: TurnoverWhereInput
  }

  /**
   * Company.nEmployees
   */
  export type Company$nEmployeesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NEmployees
     */
    select?: NEmployeesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NEmployeesInclude<ExtArgs> | null
    where?: NEmployeesWhereInput
  }

  /**
   * Company.users
   */
  export type Company$usersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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


  /**
   * Model Connection
   */

  export type AggregateConnection = {
    _count: ConnectionCountAggregateOutputType | null
    _min: ConnectionMinAggregateOutputType | null
    _max: ConnectionMaxAggregateOutputType | null
  }

  export type ConnectionMinAggregateOutputType = {
    id: string | null
    senderId: string | null
    receiverId: string | null
    accepted: boolean | null
    createdAt: Date | null
  }

  export type ConnectionMaxAggregateOutputType = {
    id: string | null
    senderId: string | null
    receiverId: string | null
    accepted: boolean | null
    createdAt: Date | null
  }

  export type ConnectionCountAggregateOutputType = {
    id: number
    senderId: number
    receiverId: number
    accepted: number
    createdAt: number
    _all: number
  }


  export type ConnectionMinAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    accepted?: true
    createdAt?: true
  }

  export type ConnectionMaxAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    accepted?: true
    createdAt?: true
  }

  export type ConnectionCountAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    accepted?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type ConnectionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ConnectionWhereInput
    orderBy?: ConnectionOrderByWithAggregationInput | ConnectionOrderByWithAggregationInput[]
    by: ConnectionScalarFieldEnum[] | ConnectionScalarFieldEnum
    having?: ConnectionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ConnectionCountAggregateInputType | true
    _min?: ConnectionMinAggregateInputType
    _max?: ConnectionMaxAggregateInputType
  }

  export type ConnectionGroupByOutputType = {
    id: string
    senderId: string
    receiverId: string
    accepted: boolean
    createdAt: Date
    _count: ConnectionCountAggregateOutputType | null
    _min: ConnectionMinAggregateOutputType | null
    _max: ConnectionMaxAggregateOutputType | null
  }

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


  export type ConnectionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    senderId?: boolean
    receiverId?: boolean
    accepted?: boolean
    createdAt?: boolean
    sender?: boolean | UserDefaultArgs<ExtArgs>
    receiver?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["connection"]>

  export type ConnectionSelectScalar = {
    id?: boolean
    senderId?: boolean
    receiverId?: boolean
    accepted?: boolean
    createdAt?: boolean
  }


  export type ConnectionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sender?: boolean | UserDefaultArgs<ExtArgs>
    receiver?: boolean | UserDefaultArgs<ExtArgs>
  }


  export type $ConnectionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Connection"
    objects: {
      sender: Prisma.$UserPayload<ExtArgs>
      receiver: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      senderId: string
      receiverId: string
      accepted: boolean
      createdAt: Date
    }, ExtArgs["result"]["connection"]>
    composites: {}
  }


  type ConnectionGetPayload<S extends boolean | null | undefined | ConnectionDefaultArgs> = $Result.GetResult<Prisma.$ConnectionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Connection.
     * @param {ConnectionCreateArgs} args - Arguments to create a Connection.
     * @example
     * // Create one Connection
     * const Connection = await prisma.connection.create({
     *   data: {
     *     // ... data to create a Connection
     *   }
     * })
     * 
    **/
    create<T extends ConnectionCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ConnectionCreateArgs<ExtArgs>>
    ): Prisma__ConnectionClient<$Result.GetResult<Prisma.$ConnectionPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Connection.
     * @param {ConnectionDeleteArgs} args - Arguments to delete one Connection.
     * @example
     * // Delete one Connection
     * const Connection = await prisma.connection.delete({
     *   where: {
     *     // ... filter to delete one Connection
     *   }
     * })
     * 
    **/
    delete<T extends ConnectionDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ConnectionDeleteArgs<ExtArgs>>
    ): Prisma__ConnectionClient<$Result.GetResult<Prisma.$ConnectionPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Connection.
     * @param {ConnectionUpdateArgs} args - Arguments to update one Connection.
     * @example
     * // Update one Connection
     * const connection = await prisma.connection.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ConnectionUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ConnectionUpdateArgs<ExtArgs>>
    ): Prisma__ConnectionClient<$Result.GetResult<Prisma.$ConnectionPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Connection.
   * 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__ConnectionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    sender<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    receiver<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 Connection model
   */ 
  interface ConnectionFieldRefs {
    readonly id: FieldRef<"Connection", 'String'>
    readonly senderId: FieldRef<"Connection", 'String'>
    readonly receiverId: FieldRef<"Connection", 'String'>
    readonly accepted: FieldRef<"Connection", 'Boolean'>
    readonly createdAt: FieldRef<"Connection", 'DateTime'>
  }
    

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

  /**
   * Connection findUniqueOrThrow
   */
  export type ConnectionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    /**
     * Filter, which Connection to fetch.
     */
    where: ConnectionWhereUniqueInput
  }

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

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

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

  /**
   * Connection create
   */
  export type ConnectionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    /**
     * The data needed to create a Connection.
     */
    data: XOR<ConnectionCreateInput, ConnectionUncheckedCreateInput>
  }

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

  /**
   * Connection update
   */
  export type ConnectionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    /**
     * The data needed to update a Connection.
     */
    data: XOR<ConnectionUpdateInput, ConnectionUncheckedUpdateInput>
    /**
     * Choose, which Connection to update.
     */
    where: ConnectionWhereUniqueInput
  }

  /**
   * Connection updateMany
   */
  export type ConnectionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Connections.
     */
    data: XOR<ConnectionUpdateManyMutationInput, ConnectionUncheckedUpdateManyInput>
    /**
     * Filter which Connections to update
     */
    where?: ConnectionWhereInput
  }

  /**
   * Connection upsert
   */
  export type ConnectionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    /**
     * The filter to search for the Connection to update in case it exists.
     */
    where: ConnectionWhereUniqueInput
    /**
     * In case the Connection found by the `where` argument doesn't exist, create a new Connection with this data.
     */
    create: XOR<ConnectionCreateInput, ConnectionUncheckedCreateInput>
    /**
     * In case the Connection was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ConnectionUpdateInput, ConnectionUncheckedUpdateInput>
  }

  /**
   * Connection delete
   */
  export type ConnectionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Connection
     */
    select?: ConnectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ConnectionInclude<ExtArgs> | null
    /**
     * Filter which Connection to delete.
     */
    where: ConnectionWhereUniqueInput
  }

  /**
   * Connection deleteMany
   */
  export type ConnectionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Connections to delete
     */
    where?: ConnectionWhereInput
  }

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


  /**
   * Model Message
   */

  export type AggregateMessage = {
    _count: MessageCountAggregateOutputType | null
    _min: MessageMinAggregateOutputType | null
    _max: MessageMaxAggregateOutputType | null
  }

  export type MessageMinAggregateOutputType = {
    id: string | null
    senderId: string | null
    receiverId: string | null
    message: string | null
    read: boolean | null
    createdAt: Date | null
  }

  export type MessageMaxAggregateOutputType = {
    id: string | null
    senderId: string | null
    receiverId: string | null
    message: string | null
    read: boolean | null
    createdAt: Date | null
  }

  export type MessageCountAggregateOutputType = {
    id: number
    senderId: number
    receiverId: number
    message: number
    read: number
    createdAt: number
    _all: number
  }


  export type MessageMinAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    message?: true
    read?: true
    createdAt?: true
  }

  export type MessageMaxAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    message?: true
    read?: true
    createdAt?: true
  }

  export type MessageCountAggregateInputType = {
    id?: true
    senderId?: true
    receiverId?: true
    message?: true
    read?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type MessageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MessageWhereInput
    orderBy?: MessageOrderByWithAggregationInput | MessageOrderByWithAggregationInput[]
    by: MessageScalarFieldEnum[] | MessageScalarFieldEnum
    having?: MessageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MessageCountAggregateInputType | true
    _min?: MessageMinAggregateInputType
    _max?: MessageMaxAggregateInputType
  }

  export type MessageGroupByOutputType = {
    id: string
    senderId: string
    receiverId: string
    message: string
    read: boolean
    createdAt: Date
    _count: MessageCountAggregateOutputType | null
    _min: MessageMinAggregateOutputType | null
    _max: MessageMaxAggregateOutputType | null
  }

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


  export type MessageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    senderId?: boolean
    receiverId?: boolean
    message?: boolean
    read?: boolean
    createdAt?: boolean
    sender?: boolean | UserDefaultArgs<ExtArgs>
    receiver?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["message"]>

  export type MessageSelectScalar = {
    id?: boolean
    senderId?: boolean
    receiverId?: boolean
    message?: boolean
    read?: boolean
    createdAt?: boolean
  }


  export type MessageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sender?: boolean | UserDefaultArgs<ExtArgs>
    receiver?: boolean | UserDefaultArgs<ExtArgs>
  }


  export type $MessagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Message"
    objects: {
      sender: Prisma.$UserPayload<ExtArgs>
      receiver: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      senderId: string
      receiverId: string
      message: string
      read: boolean
      createdAt: Date
    }, ExtArgs["result"]["message"]>
    composites: {}
  }


  type MessageGetPayload<S extends boolean | null | undefined | MessageDefaultArgs> = $Result.GetResult<Prisma.$MessagePayload, S>

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

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

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

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

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

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

    /**
     * Create a Message.
     * @param {MessageCreateArgs} args - Arguments to create a Message.
     * @example
     * // Create one Message
     * const Message = await prisma.message.create({
     *   data: {
     *     // ... data to create a Message
     *   }
     * })
     * 
    **/
    create<T extends MessageCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MessageCreateArgs<ExtArgs>>
    ): Prisma__MessageClient<$Result.GetResult<Prisma.$MessagePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Message.
     * @param {MessageDeleteArgs} args - Arguments to delete one Message.
     * @example
     * // Delete one Message
     * const Message = await prisma.message.delete({
     *   where: {
     *     // ... filter to delete one Message
     *   }
     * })
     * 
    **/
    delete<T extends MessageDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MessageDeleteArgs<ExtArgs>>
    ): Prisma__MessageClient<$Result.GetResult<Prisma.$MessagePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Message.
     * @param {MessageUpdateArgs} args - Arguments to update one Message.
     * @example
     * // Update one Message
     * const message = await prisma.message.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MessageUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, MessageUpdateArgs<ExtArgs>>
    ): Prisma__MessageClient<$Result.GetResult<Prisma.$MessagePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Message.
   * 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__MessageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    sender<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    receiver<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 Message model
   */ 
  interface MessageFieldRefs {
    readonly id: FieldRef<"Message", 'String'>
    readonly senderId: FieldRef<"Message", 'String'>
    readonly receiverId: FieldRef<"Message", 'String'>
    readonly message: FieldRef<"Message", 'String'>
    readonly read: FieldRef<"Message", 'Boolean'>
    readonly createdAt: FieldRef<"Message", 'DateTime'>
  }
    

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

  /**
   * Message findUniqueOrThrow
   */
  export type MessageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    /**
     * Filter, which Message to fetch.
     */
    where: MessageWhereUniqueInput
  }

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

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

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

  /**
   * Message create
   */
  export type MessageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    /**
     * The data needed to create a Message.
     */
    data: XOR<MessageCreateInput, MessageUncheckedCreateInput>
  }

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

  /**
   * Message update
   */
  export type MessageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    /**
     * The data needed to update a Message.
     */
    data: XOR<MessageUpdateInput, MessageUncheckedUpdateInput>
    /**
     * Choose, which Message to update.
     */
    where: MessageWhereUniqueInput
  }

  /**
   * Message updateMany
   */
  export type MessageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Messages.
     */
    data: XOR<MessageUpdateManyMutationInput, MessageUncheckedUpdateManyInput>
    /**
     * Filter which Messages to update
     */
    where?: MessageWhereInput
  }

  /**
   * Message upsert
   */
  export type MessageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    /**
     * The filter to search for the Message to update in case it exists.
     */
    where: MessageWhereUniqueInput
    /**
     * In case the Message found by the `where` argument doesn't exist, create a new Message with this data.
     */
    create: XOR<MessageCreateInput, MessageUncheckedCreateInput>
    /**
     * In case the Message was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MessageUpdateInput, MessageUncheckedUpdateInput>
  }

  /**
   * Message delete
   */
  export type MessageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Message
     */
    select?: MessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MessageInclude<ExtArgs> | null
    /**
     * Filter which Message to delete.
     */
    where: MessageWhereUniqueInput
  }

  /**
   * Message deleteMany
   */
  export type MessageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Messages to delete
     */
    where?: MessageWhereInput
  }

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


  /**
   * Model Opportunity
   */

  export type AggregateOpportunity = {
    _count: OpportunityCountAggregateOutputType | null
    _min: OpportunityMinAggregateOutputType | null
    _max: OpportunityMaxAggregateOutputType | null
  }

  export type OpportunityMinAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    companyName: string | null
    country: string | null
    address: string | null
    requirements: string | null
    contactEmail: string | null
    contactPhoneNumber: string | null
    creatorId: string | null
    document: string | null
    verified: boolean | null
    active: boolean | null
    validityDate: Date | null
    createdAt: Date | null
  }

  export type OpportunityMaxAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    companyName: string | null
    country: string | null
    address: string | null
    requirements: string | null
    contactEmail: string | null
    contactPhoneNumber: string | null
    creatorId: string | null
    document: string | null
    verified: boolean | null
    active: boolean | null
    validityDate: Date | null
    createdAt: Date | null
  }

  export type OpportunityCountAggregateOutputType = {
    id: number
    title: number
    description: number
    companyName: number
    activitiesFamilies: number
    activities: number
    country: number
    address: number
    requirements: number
    contactEmail: number
    contactPhoneNumber: number
    creatorId: number
    document: number
    verified: number
    active: number
    validityDate: number
    createdAt: number
    _all: number
  }


  export type OpportunityMinAggregateInputType = {
    id?: true
    title?: true
    description?: true
    companyName?: true
    country?: true
    address?: true
    requirements?: true
    contactEmail?: true
    contactPhoneNumber?: true
    creatorId?: true
    document?: true
    verified?: true
    active?: true
    validityDate?: true
    createdAt?: true
  }

  export type OpportunityMaxAggregateInputType = {
    id?: true
    title?: true
    description?: true
    companyName?: true
    country?: true
    address?: true
    requirements?: true
    contactEmail?: true
    contactPhoneNumber?: true
    creatorId?: true
    document?: true
    verified?: true
    active?: true
    validityDate?: true
    createdAt?: true
  }

  export type OpportunityCountAggregateInputType = {
    id?: true
    title?: true
    description?: true
    companyName?: true
    activitiesFamilies?: true
    activities?: true
    country?: true
    address?: true
    requirements?: true
    contactEmail?: true
    contactPhoneNumber?: true
    creatorId?: true
    document?: true
    verified?: true
    active?: true
    validityDate?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type OpportunityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OpportunityWhereInput
    orderBy?: OpportunityOrderByWithAggregationInput | OpportunityOrderByWithAggregationInput[]
    by: OpportunityScalarFieldEnum[] | OpportunityScalarFieldEnum
    having?: OpportunityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OpportunityCountAggregateInputType | true
    _min?: OpportunityMinAggregateInputType
    _max?: OpportunityMaxAggregateInputType
  }

  export type OpportunityGroupByOutputType = {
    id: string
    title: string
    description: string
    companyName: string
    activitiesFamilies: string[]
    activities: string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    creatorId: string
    document: string | null
    verified: boolean
    active: boolean
    validityDate: Date | null
    createdAt: Date
    _count: OpportunityCountAggregateOutputType | null
    _min: OpportunityMinAggregateOutputType | null
    _max: OpportunityMaxAggregateOutputType | null
  }

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


  export type OpportunitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    companyName?: boolean
    activitiesFamilies?: boolean
    activities?: boolean
    country?: boolean
    address?: boolean
    requirements?: boolean
    contactEmail?: boolean
    contactPhoneNumber?: boolean
    creatorId?: boolean
    document?: boolean
    verified?: boolean
    active?: boolean
    validityDate?: boolean
    createdAt?: boolean
    creator?: boolean | UserDefaultArgs<ExtArgs>
    likes?: boolean | Opportunity$likesArgs<ExtArgs>
    comments?: boolean | Opportunity$commentsArgs<ExtArgs>
    _count?: boolean | OpportunityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["opportunity"]>

  export type OpportunitySelectScalar = {
    id?: boolean
    title?: boolean
    description?: boolean
    companyName?: boolean
    activitiesFamilies?: boolean
    activities?: boolean
    country?: boolean
    address?: boolean
    requirements?: boolean
    contactEmail?: boolean
    contactPhoneNumber?: boolean
    creatorId?: boolean
    document?: boolean
    verified?: boolean
    active?: boolean
    validityDate?: boolean
    createdAt?: boolean
  }


  export type OpportunityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    creator?: boolean | UserDefaultArgs<ExtArgs>
    likes?: boolean | Opportunity$likesArgs<ExtArgs>
    comments?: boolean | Opportunity$commentsArgs<ExtArgs>
    _count?: boolean | OpportunityCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $OpportunityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Opportunity"
    objects: {
      creator: Prisma.$UserPayload<ExtArgs>
      likes: Prisma.$OpportunityLikePayload<ExtArgs>[]
      comments: Prisma.$OpportunityCommentPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      description: string
      companyName: string
      activitiesFamilies: string[]
      activities: string[]
      country: string
      address: string
      requirements: string
      contactEmail: string
      contactPhoneNumber: string
      creatorId: string
      document: string | null
      verified: boolean
      active: boolean
      validityDate: Date | null
      createdAt: Date
    }, ExtArgs["result"]["opportunity"]>
    composites: {}
  }


  type OpportunityGetPayload<S extends boolean | null | undefined | OpportunityDefaultArgs> = $Result.GetResult<Prisma.$OpportunityPayload, S>

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

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

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

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

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

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

    /**
     * Create a Opportunity.
     * @param {OpportunityCreateArgs} args - Arguments to create a Opportunity.
     * @example
     * // Create one Opportunity
     * const Opportunity = await prisma.opportunity.create({
     *   data: {
     *     // ... data to create a Opportunity
     *   }
     * })
     * 
    **/
    create<T extends OpportunityCreateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityCreateArgs<ExtArgs>>
    ): Prisma__OpportunityClient<$Result.GetResult<Prisma.$OpportunityPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Opportunity.
     * @param {OpportunityDeleteArgs} args - Arguments to delete one Opportunity.
     * @example
     * // Delete one Opportunity
     * const Opportunity = await prisma.opportunity.delete({
     *   where: {
     *     // ... filter to delete one Opportunity
     *   }
     * })
     * 
    **/
    delete<T extends OpportunityDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityDeleteArgs<ExtArgs>>
    ): Prisma__OpportunityClient<$Result.GetResult<Prisma.$OpportunityPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Opportunity.
     * @param {OpportunityUpdateArgs} args - Arguments to update one Opportunity.
     * @example
     * // Update one Opportunity
     * const opportunity = await prisma.opportunity.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OpportunityUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityUpdateArgs<ExtArgs>>
    ): Prisma__OpportunityClient<$Result.GetResult<Prisma.$OpportunityPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Opportunity.
   * 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__OpportunityClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    creator<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    likes<T extends Opportunity$likesArgs<ExtArgs> = {}>(args?: Subset<T, Opportunity$likesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OpportunityLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    comments<T extends Opportunity$commentsArgs<ExtArgs> = {}>(args?: Subset<T, Opportunity$commentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OpportunityCommentPayload<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 Opportunity model
   */ 
  interface OpportunityFieldRefs {
    readonly id: FieldRef<"Opportunity", 'String'>
    readonly title: FieldRef<"Opportunity", 'String'>
    readonly description: FieldRef<"Opportunity", 'String'>
    readonly companyName: FieldRef<"Opportunity", 'String'>
    readonly activitiesFamilies: FieldRef<"Opportunity", 'String[]'>
    readonly activities: FieldRef<"Opportunity", 'String[]'>
    readonly country: FieldRef<"Opportunity", 'String'>
    readonly address: FieldRef<"Opportunity", 'String'>
    readonly requirements: FieldRef<"Opportunity", 'String'>
    readonly contactEmail: FieldRef<"Opportunity", 'String'>
    readonly contactPhoneNumber: FieldRef<"Opportunity", 'String'>
    readonly creatorId: FieldRef<"Opportunity", 'String'>
    readonly document: FieldRef<"Opportunity", 'String'>
    readonly verified: FieldRef<"Opportunity", 'Boolean'>
    readonly active: FieldRef<"Opportunity", 'Boolean'>
    readonly validityDate: FieldRef<"Opportunity", 'DateTime'>
    readonly createdAt: FieldRef<"Opportunity", 'DateTime'>
  }
    

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

  /**
   * Opportunity findUniqueOrThrow
   */
  export type OpportunityFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    /**
     * Filter, which Opportunity to fetch.
     */
    where: OpportunityWhereUniqueInput
  }

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

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

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

  /**
   * Opportunity create
   */
  export type OpportunityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    /**
     * The data needed to create a Opportunity.
     */
    data: XOR<OpportunityCreateInput, OpportunityUncheckedCreateInput>
  }

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

  /**
   * Opportunity update
   */
  export type OpportunityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    /**
     * The data needed to update a Opportunity.
     */
    data: XOR<OpportunityUpdateInput, OpportunityUncheckedUpdateInput>
    /**
     * Choose, which Opportunity to update.
     */
    where: OpportunityWhereUniqueInput
  }

  /**
   * Opportunity updateMany
   */
  export type OpportunityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Opportunities.
     */
    data: XOR<OpportunityUpdateManyMutationInput, OpportunityUncheckedUpdateManyInput>
    /**
     * Filter which Opportunities to update
     */
    where?: OpportunityWhereInput
  }

  /**
   * Opportunity upsert
   */
  export type OpportunityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    /**
     * The filter to search for the Opportunity to update in case it exists.
     */
    where: OpportunityWhereUniqueInput
    /**
     * In case the Opportunity found by the `where` argument doesn't exist, create a new Opportunity with this data.
     */
    create: XOR<OpportunityCreateInput, OpportunityUncheckedCreateInput>
    /**
     * In case the Opportunity was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OpportunityUpdateInput, OpportunityUncheckedUpdateInput>
  }

  /**
   * Opportunity delete
   */
  export type OpportunityDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Opportunity
     */
    select?: OpportunitySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityInclude<ExtArgs> | null
    /**
     * Filter which Opportunity to delete.
     */
    where: OpportunityWhereUniqueInput
  }

  /**
   * Opportunity deleteMany
   */
  export type OpportunityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Opportunities to delete
     */
    where?: OpportunityWhereInput
  }

  /**
   * Opportunity.likes
   */
  export type Opportunity$likesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    where?: OpportunityLikeWhereInput
    orderBy?: OpportunityLikeOrderByWithRelationInput | OpportunityLikeOrderByWithRelationInput[]
    cursor?: OpportunityLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OpportunityLikeScalarFieldEnum | OpportunityLikeScalarFieldEnum[]
  }

  /**
   * Opportunity.comments
   */
  export type Opportunity$commentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    where?: OpportunityCommentWhereInput
    orderBy?: OpportunityCommentOrderByWithRelationInput | OpportunityCommentOrderByWithRelationInput[]
    cursor?: OpportunityCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OpportunityCommentScalarFieldEnum | OpportunityCommentScalarFieldEnum[]
  }

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


  /**
   * Model OpportunityLike
   */

  export type AggregateOpportunityLike = {
    _count: OpportunityLikeCountAggregateOutputType | null
    _min: OpportunityLikeMinAggregateOutputType | null
    _max: OpportunityLikeMaxAggregateOutputType | null
  }

  export type OpportunityLikeMinAggregateOutputType = {
    id: string | null
    userId: string | null
    opportunityId: string | null
  }

  export type OpportunityLikeMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    opportunityId: string | null
  }

  export type OpportunityLikeCountAggregateOutputType = {
    id: number
    userId: number
    opportunityId: number
    _all: number
  }


  export type OpportunityLikeMinAggregateInputType = {
    id?: true
    userId?: true
    opportunityId?: true
  }

  export type OpportunityLikeMaxAggregateInputType = {
    id?: true
    userId?: true
    opportunityId?: true
  }

  export type OpportunityLikeCountAggregateInputType = {
    id?: true
    userId?: true
    opportunityId?: true
    _all?: true
  }

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

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




  export type OpportunityLikeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OpportunityLikeWhereInput
    orderBy?: OpportunityLikeOrderByWithAggregationInput | OpportunityLikeOrderByWithAggregationInput[]
    by: OpportunityLikeScalarFieldEnum[] | OpportunityLikeScalarFieldEnum
    having?: OpportunityLikeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OpportunityLikeCountAggregateInputType | true
    _min?: OpportunityLikeMinAggregateInputType
    _max?: OpportunityLikeMaxAggregateInputType
  }

  export type OpportunityLikeGroupByOutputType = {
    id: string
    userId: string
    opportunityId: string
    _count: OpportunityLikeCountAggregateOutputType | null
    _min: OpportunityLikeMinAggregateOutputType | null
    _max: OpportunityLikeMaxAggregateOutputType | null
  }

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


  export type OpportunityLikeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    opportunityId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    opportunity?: boolean | OpportunityDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["opportunityLike"]>

  export type OpportunityLikeSelectScalar = {
    id?: boolean
    userId?: boolean
    opportunityId?: boolean
  }


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


  export type $OpportunityLikePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OpportunityLike"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      opportunity: Prisma.$OpportunityPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      opportunityId: string
    }, ExtArgs["result"]["opportunityLike"]>
    composites: {}
  }


  type OpportunityLikeGetPayload<S extends boolean | null | undefined | OpportunityLikeDefaultArgs> = $Result.GetResult<Prisma.$OpportunityLikePayload, S>

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

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

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

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

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

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

    /**
     * Create a OpportunityLike.
     * @param {OpportunityLikeCreateArgs} args - Arguments to create a OpportunityLike.
     * @example
     * // Create one OpportunityLike
     * const OpportunityLike = await prisma.opportunityLike.create({
     *   data: {
     *     // ... data to create a OpportunityLike
     *   }
     * })
     * 
    **/
    create<T extends OpportunityLikeCreateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityLikeCreateArgs<ExtArgs>>
    ): Prisma__OpportunityLikeClient<$Result.GetResult<Prisma.$OpportunityLikePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a OpportunityLike.
     * @param {OpportunityLikeDeleteArgs} args - Arguments to delete one OpportunityLike.
     * @example
     * // Delete one OpportunityLike
     * const OpportunityLike = await prisma.opportunityLike.delete({
     *   where: {
     *     // ... filter to delete one OpportunityLike
     *   }
     * })
     * 
    **/
    delete<T extends OpportunityLikeDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityLikeDeleteArgs<ExtArgs>>
    ): Prisma__OpportunityLikeClient<$Result.GetResult<Prisma.$OpportunityLikePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one OpportunityLike.
     * @param {OpportunityLikeUpdateArgs} args - Arguments to update one OpportunityLike.
     * @example
     * // Update one OpportunityLike
     * const opportunityLike = await prisma.opportunityLike.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OpportunityLikeUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityLikeUpdateArgs<ExtArgs>>
    ): Prisma__OpportunityLikeClient<$Result.GetResult<Prisma.$OpportunityLikePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OpportunityLike.
   * 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__OpportunityLikeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    opportunity<T extends OpportunityDefaultArgs<ExtArgs> = {}>(args?: Subset<T, OpportunityDefaultArgs<ExtArgs>>): Prisma__OpportunityClient<$Result.GetResult<Prisma.$OpportunityPayload<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 OpportunityLike model
   */ 
  interface OpportunityLikeFieldRefs {
    readonly id: FieldRef<"OpportunityLike", 'String'>
    readonly userId: FieldRef<"OpportunityLike", 'String'>
    readonly opportunityId: FieldRef<"OpportunityLike", 'String'>
  }
    

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

  /**
   * OpportunityLike findUniqueOrThrow
   */
  export type OpportunityLikeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    /**
     * Filter, which OpportunityLike to fetch.
     */
    where: OpportunityLikeWhereUniqueInput
  }

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

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

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

  /**
   * OpportunityLike create
   */
  export type OpportunityLikeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    /**
     * The data needed to create a OpportunityLike.
     */
    data: XOR<OpportunityLikeCreateInput, OpportunityLikeUncheckedCreateInput>
  }

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

  /**
   * OpportunityLike update
   */
  export type OpportunityLikeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    /**
     * The data needed to update a OpportunityLike.
     */
    data: XOR<OpportunityLikeUpdateInput, OpportunityLikeUncheckedUpdateInput>
    /**
     * Choose, which OpportunityLike to update.
     */
    where: OpportunityLikeWhereUniqueInput
  }

  /**
   * OpportunityLike updateMany
   */
  export type OpportunityLikeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OpportunityLikes.
     */
    data: XOR<OpportunityLikeUpdateManyMutationInput, OpportunityLikeUncheckedUpdateManyInput>
    /**
     * Filter which OpportunityLikes to update
     */
    where?: OpportunityLikeWhereInput
  }

  /**
   * OpportunityLike upsert
   */
  export type OpportunityLikeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    /**
     * The filter to search for the OpportunityLike to update in case it exists.
     */
    where: OpportunityLikeWhereUniqueInput
    /**
     * In case the OpportunityLike found by the `where` argument doesn't exist, create a new OpportunityLike with this data.
     */
    create: XOR<OpportunityLikeCreateInput, OpportunityLikeUncheckedCreateInput>
    /**
     * In case the OpportunityLike was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OpportunityLikeUpdateInput, OpportunityLikeUncheckedUpdateInput>
  }

  /**
   * OpportunityLike delete
   */
  export type OpportunityLikeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityLike
     */
    select?: OpportunityLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityLikeInclude<ExtArgs> | null
    /**
     * Filter which OpportunityLike to delete.
     */
    where: OpportunityLikeWhereUniqueInput
  }

  /**
   * OpportunityLike deleteMany
   */
  export type OpportunityLikeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OpportunityLikes to delete
     */
    where?: OpportunityLikeWhereInput
  }

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


  /**
   * Model OpportunityComment
   */

  export type AggregateOpportunityComment = {
    _count: OpportunityCommentCountAggregateOutputType | null
    _min: OpportunityCommentMinAggregateOutputType | null
    _max: OpportunityCommentMaxAggregateOutputType | null
  }

  export type OpportunityCommentMinAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    opportunityId: string | null
    createdAt: Date | null
  }

  export type OpportunityCommentMaxAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    opportunityId: string | null
    createdAt: Date | null
  }

  export type OpportunityCommentCountAggregateOutputType = {
    id: number
    content: number
    userId: number
    opportunityId: number
    createdAt: number
    _all: number
  }


  export type OpportunityCommentMinAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    opportunityId?: true
    createdAt?: true
  }

  export type OpportunityCommentMaxAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    opportunityId?: true
    createdAt?: true
  }

  export type OpportunityCommentCountAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    opportunityId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type OpportunityCommentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OpportunityCommentWhereInput
    orderBy?: OpportunityCommentOrderByWithAggregationInput | OpportunityCommentOrderByWithAggregationInput[]
    by: OpportunityCommentScalarFieldEnum[] | OpportunityCommentScalarFieldEnum
    having?: OpportunityCommentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OpportunityCommentCountAggregateInputType | true
    _min?: OpportunityCommentMinAggregateInputType
    _max?: OpportunityCommentMaxAggregateInputType
  }

  export type OpportunityCommentGroupByOutputType = {
    id: string
    content: string
    userId: string
    opportunityId: string
    createdAt: Date
    _count: OpportunityCommentCountAggregateOutputType | null
    _min: OpportunityCommentMinAggregateOutputType | null
    _max: OpportunityCommentMaxAggregateOutputType | null
  }

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


  export type OpportunityCommentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    userId?: boolean
    opportunityId?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    opportunity?: boolean | OpportunityDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["opportunityComment"]>

  export type OpportunityCommentSelectScalar = {
    id?: boolean
    content?: boolean
    userId?: boolean
    opportunityId?: boolean
    createdAt?: boolean
  }


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


  export type $OpportunityCommentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OpportunityComment"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      opportunity: Prisma.$OpportunityPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      content: string
      userId: string
      opportunityId: string
      createdAt: Date
    }, ExtArgs["result"]["opportunityComment"]>
    composites: {}
  }


  type OpportunityCommentGetPayload<S extends boolean | null | undefined | OpportunityCommentDefaultArgs> = $Result.GetResult<Prisma.$OpportunityCommentPayload, S>

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

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

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

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

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

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

    /**
     * Create a OpportunityComment.
     * @param {OpportunityCommentCreateArgs} args - Arguments to create a OpportunityComment.
     * @example
     * // Create one OpportunityComment
     * const OpportunityComment = await prisma.opportunityComment.create({
     *   data: {
     *     // ... data to create a OpportunityComment
     *   }
     * })
     * 
    **/
    create<T extends OpportunityCommentCreateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityCommentCreateArgs<ExtArgs>>
    ): Prisma__OpportunityCommentClient<$Result.GetResult<Prisma.$OpportunityCommentPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a OpportunityComment.
     * @param {OpportunityCommentDeleteArgs} args - Arguments to delete one OpportunityComment.
     * @example
     * // Delete one OpportunityComment
     * const OpportunityComment = await prisma.opportunityComment.delete({
     *   where: {
     *     // ... filter to delete one OpportunityComment
     *   }
     * })
     * 
    **/
    delete<T extends OpportunityCommentDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityCommentDeleteArgs<ExtArgs>>
    ): Prisma__OpportunityCommentClient<$Result.GetResult<Prisma.$OpportunityCommentPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one OpportunityComment.
     * @param {OpportunityCommentUpdateArgs} args - Arguments to update one OpportunityComment.
     * @example
     * // Update one OpportunityComment
     * const opportunityComment = await prisma.opportunityComment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OpportunityCommentUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, OpportunityCommentUpdateArgs<ExtArgs>>
    ): Prisma__OpportunityCommentClient<$Result.GetResult<Prisma.$OpportunityCommentPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OpportunityComment.
   * 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__OpportunityCommentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    opportunity<T extends OpportunityDefaultArgs<ExtArgs> = {}>(args?: Subset<T, OpportunityDefaultArgs<ExtArgs>>): Prisma__OpportunityClient<$Result.GetResult<Prisma.$OpportunityPayload<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 OpportunityComment model
   */ 
  interface OpportunityCommentFieldRefs {
    readonly id: FieldRef<"OpportunityComment", 'String'>
    readonly content: FieldRef<"OpportunityComment", 'String'>
    readonly userId: FieldRef<"OpportunityComment", 'String'>
    readonly opportunityId: FieldRef<"OpportunityComment", 'String'>
    readonly createdAt: FieldRef<"OpportunityComment", 'DateTime'>
  }
    

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

  /**
   * OpportunityComment findUniqueOrThrow
   */
  export type OpportunityCommentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    /**
     * Filter, which OpportunityComment to fetch.
     */
    where: OpportunityCommentWhereUniqueInput
  }

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

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

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

  /**
   * OpportunityComment create
   */
  export type OpportunityCommentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    /**
     * The data needed to create a OpportunityComment.
     */
    data: XOR<OpportunityCommentCreateInput, OpportunityCommentUncheckedCreateInput>
  }

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

  /**
   * OpportunityComment update
   */
  export type OpportunityCommentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    /**
     * The data needed to update a OpportunityComment.
     */
    data: XOR<OpportunityCommentUpdateInput, OpportunityCommentUncheckedUpdateInput>
    /**
     * Choose, which OpportunityComment to update.
     */
    where: OpportunityCommentWhereUniqueInput
  }

  /**
   * OpportunityComment updateMany
   */
  export type OpportunityCommentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OpportunityComments.
     */
    data: XOR<OpportunityCommentUpdateManyMutationInput, OpportunityCommentUncheckedUpdateManyInput>
    /**
     * Filter which OpportunityComments to update
     */
    where?: OpportunityCommentWhereInput
  }

  /**
   * OpportunityComment upsert
   */
  export type OpportunityCommentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    /**
     * The filter to search for the OpportunityComment to update in case it exists.
     */
    where: OpportunityCommentWhereUniqueInput
    /**
     * In case the OpportunityComment found by the `where` argument doesn't exist, create a new OpportunityComment with this data.
     */
    create: XOR<OpportunityCommentCreateInput, OpportunityCommentUncheckedCreateInput>
    /**
     * In case the OpportunityComment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OpportunityCommentUpdateInput, OpportunityCommentUncheckedUpdateInput>
  }

  /**
   * OpportunityComment delete
   */
  export type OpportunityCommentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OpportunityComment
     */
    select?: OpportunityCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OpportunityCommentInclude<ExtArgs> | null
    /**
     * Filter which OpportunityComment to delete.
     */
    where: OpportunityCommentWhereUniqueInput
  }

  /**
   * OpportunityComment deleteMany
   */
  export type OpportunityCommentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OpportunityComments to delete
     */
    where?: OpportunityCommentWhereInput
  }

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


  /**
   * Model Event
   */

  export type AggregateEvent = {
    _count: EventCountAggregateOutputType | null
    _min: EventMinAggregateOutputType | null
    _max: EventMaxAggregateOutputType | null
  }

  export type EventMinAggregateOutputType = {
    id: string | null
    title: string | null
    briefDescription: string | null
    description: string | null
    date: Date | null
    active: boolean | null
  }

  export type EventMaxAggregateOutputType = {
    id: string | null
    title: string | null
    briefDescription: string | null
    description: string | null
    date: Date | null
    active: boolean | null
  }

  export type EventCountAggregateOutputType = {
    id: number
    title: number
    briefDescription: number
    description: number
    date: number
    active: number
    images: number
    _all: number
  }


  export type EventMinAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    active?: true
  }

  export type EventMaxAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    active?: true
  }

  export type EventCountAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    active?: true
    images?: 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 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
    _min?: EventMinAggregateInputType
    _max?: EventMaxAggregateInputType
  }

  export type EventGroupByOutputType = {
    id: string
    title: string
    briefDescription: string
    description: string
    date: Date
    active: boolean
    images: string[]
    _count: EventCountAggregateOutputType | 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
    briefDescription?: boolean
    description?: boolean
    date?: boolean
    active?: boolean
    images?: boolean
    likes?: boolean | Event$likesArgs<ExtArgs>
    comments?: boolean | Event$commentsArgs<ExtArgs>
    _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["event"]>

  export type EventSelectScalar = {
    id?: boolean
    title?: boolean
    briefDescription?: boolean
    description?: boolean
    date?: boolean
    active?: boolean
    images?: boolean
  }


  export type EventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | Event$likesArgs<ExtArgs>
    comments?: boolean | Event$commentsArgs<ExtArgs>
    _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $EventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Event"
    objects: {
      likes: Prisma.$EventLikePayload<ExtArgs>[]
      comments: Prisma.$EventCommentPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      briefDescription: string
      description: string
      date: Date
      active: boolean
      images: string[]
    }, 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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      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<ExtArgs>>(
      args?: SelectSubset<T, EventCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

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

    likes<T extends Event$likesArgs<ExtArgs> = {}>(args?: Subset<T, Event$likesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    comments<T extends Event$commentsArgs<ExtArgs> = {}>(args?: Subset<T, Event$commentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventCommentPayload<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 briefDescription: FieldRef<"Event", 'String'>
    readonly description: FieldRef<"Event", 'String'>
    readonly date: FieldRef<"Event", 'DateTime'>
    readonly active: FieldRef<"Event", 'Boolean'>
    readonly images: FieldRef<"Event", 'String[]'>
  }
    

  // 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 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.likes
   */
  export type Event$likesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    where?: EventLikeWhereInput
    orderBy?: EventLikeOrderByWithRelationInput | EventLikeOrderByWithRelationInput[]
    cursor?: EventLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventLikeScalarFieldEnum | EventLikeScalarFieldEnum[]
  }

  /**
   * Event.comments
   */
  export type Event$commentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    where?: EventCommentWhereInput
    orderBy?: EventCommentOrderByWithRelationInput | EventCommentOrderByWithRelationInput[]
    cursor?: EventCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: EventCommentScalarFieldEnum | EventCommentScalarFieldEnum[]
  }

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

  export type AggregateEventLike = {
    _count: EventLikeCountAggregateOutputType | null
    _min: EventLikeMinAggregateOutputType | null
    _max: EventLikeMaxAggregateOutputType | null
  }

  export type EventLikeMinAggregateOutputType = {
    id: string | null
    userId: string | null
    eventId: string | null
  }

  export type EventLikeMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    eventId: string | null
  }

  export type EventLikeCountAggregateOutputType = {
    id: number
    userId: number
    eventId: number
    _all: number
  }


  export type EventLikeMinAggregateInputType = {
    id?: true
    userId?: true
    eventId?: true
  }

  export type EventLikeMaxAggregateInputType = {
    id?: true
    userId?: true
    eventId?: true
  }

  export type EventLikeCountAggregateInputType = {
    id?: true
    userId?: true
    eventId?: true
    _all?: true
  }

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

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




  export type EventLikeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventLikeWhereInput
    orderBy?: EventLikeOrderByWithAggregationInput | EventLikeOrderByWithAggregationInput[]
    by: EventLikeScalarFieldEnum[] | EventLikeScalarFieldEnum
    having?: EventLikeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventLikeCountAggregateInputType | true
    _min?: EventLikeMinAggregateInputType
    _max?: EventLikeMaxAggregateInputType
  }

  export type EventLikeGroupByOutputType = {
    id: string
    userId: string
    eventId: string
    _count: EventLikeCountAggregateOutputType | null
    _min: EventLikeMinAggregateOutputType | null
    _max: EventLikeMaxAggregateOutputType | null
  }

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


  export type EventLikeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    eventId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    event?: boolean | EventDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["eventLike"]>

  export type EventLikeSelectScalar = {
    id?: boolean
    userId?: boolean
    eventId?: boolean
  }


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


  export type $EventLikePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "EventLike"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      event: Prisma.$EventPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      eventId: string
    }, ExtArgs["result"]["eventLike"]>
    composites: {}
  }


  type EventLikeGetPayload<S extends boolean | null | undefined | EventLikeDefaultArgs> = $Result.GetResult<Prisma.$EventLikePayload, S>

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

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

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

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

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

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

    /**
     * Create a EventLike.
     * @param {EventLikeCreateArgs} args - Arguments to create a EventLike.
     * @example
     * // Create one EventLike
     * const EventLike = await prisma.eventLike.create({
     *   data: {
     *     // ... data to create a EventLike
     *   }
     * })
     * 
    **/
    create<T extends EventLikeCreateArgs<ExtArgs>>(
      args: SelectSubset<T, EventLikeCreateArgs<ExtArgs>>
    ): Prisma__EventLikeClient<$Result.GetResult<Prisma.$EventLikePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a EventLike.
     * @param {EventLikeDeleteArgs} args - Arguments to delete one EventLike.
     * @example
     * // Delete one EventLike
     * const EventLike = await prisma.eventLike.delete({
     *   where: {
     *     // ... filter to delete one EventLike
     *   }
     * })
     * 
    **/
    delete<T extends EventLikeDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, EventLikeDeleteArgs<ExtArgs>>
    ): Prisma__EventLikeClient<$Result.GetResult<Prisma.$EventLikePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one EventLike.
     * @param {EventLikeUpdateArgs} args - Arguments to update one EventLike.
     * @example
     * // Update one EventLike
     * const eventLike = await prisma.eventLike.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends EventLikeUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, EventLikeUpdateArgs<ExtArgs>>
    ): Prisma__EventLikeClient<$Result.GetResult<Prisma.$EventLikePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for EventLike.
   * 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__EventLikeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    event<T extends EventDefaultArgs<ExtArgs> = {}>(args?: Subset<T, EventDefaultArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<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 EventLike model
   */ 
  interface EventLikeFieldRefs {
    readonly id: FieldRef<"EventLike", 'String'>
    readonly userId: FieldRef<"EventLike", 'String'>
    readonly eventId: FieldRef<"EventLike", 'String'>
  }
    

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

  /**
   * EventLike findUniqueOrThrow
   */
  export type EventLikeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    /**
     * Filter, which EventLike to fetch.
     */
    where: EventLikeWhereUniqueInput
  }

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

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

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

  /**
   * EventLike create
   */
  export type EventLikeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    /**
     * The data needed to create a EventLike.
     */
    data: XOR<EventLikeCreateInput, EventLikeUncheckedCreateInput>
  }

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

  /**
   * EventLike update
   */
  export type EventLikeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    /**
     * The data needed to update a EventLike.
     */
    data: XOR<EventLikeUpdateInput, EventLikeUncheckedUpdateInput>
    /**
     * Choose, which EventLike to update.
     */
    where: EventLikeWhereUniqueInput
  }

  /**
   * EventLike updateMany
   */
  export type EventLikeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update EventLikes.
     */
    data: XOR<EventLikeUpdateManyMutationInput, EventLikeUncheckedUpdateManyInput>
    /**
     * Filter which EventLikes to update
     */
    where?: EventLikeWhereInput
  }

  /**
   * EventLike upsert
   */
  export type EventLikeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    /**
     * The filter to search for the EventLike to update in case it exists.
     */
    where: EventLikeWhereUniqueInput
    /**
     * In case the EventLike found by the `where` argument doesn't exist, create a new EventLike with this data.
     */
    create: XOR<EventLikeCreateInput, EventLikeUncheckedCreateInput>
    /**
     * In case the EventLike was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EventLikeUpdateInput, EventLikeUncheckedUpdateInput>
  }

  /**
   * EventLike delete
   */
  export type EventLikeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLike
     */
    select?: EventLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventLikeInclude<ExtArgs> | null
    /**
     * Filter which EventLike to delete.
     */
    where: EventLikeWhereUniqueInput
  }

  /**
   * EventLike deleteMany
   */
  export type EventLikeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which EventLikes to delete
     */
    where?: EventLikeWhereInput
  }

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


  /**
   * Model EventComment
   */

  export type AggregateEventComment = {
    _count: EventCommentCountAggregateOutputType | null
    _min: EventCommentMinAggregateOutputType | null
    _max: EventCommentMaxAggregateOutputType | null
  }

  export type EventCommentMinAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    eventId: string | null
    createdAt: Date | null
  }

  export type EventCommentMaxAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    eventId: string | null
    createdAt: Date | null
  }

  export type EventCommentCountAggregateOutputType = {
    id: number
    content: number
    userId: number
    eventId: number
    createdAt: number
    _all: number
  }


  export type EventCommentMinAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    eventId?: true
    createdAt?: true
  }

  export type EventCommentMaxAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    eventId?: true
    createdAt?: true
  }

  export type EventCommentCountAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    eventId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type EventCommentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventCommentWhereInput
    orderBy?: EventCommentOrderByWithAggregationInput | EventCommentOrderByWithAggregationInput[]
    by: EventCommentScalarFieldEnum[] | EventCommentScalarFieldEnum
    having?: EventCommentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventCommentCountAggregateInputType | true
    _min?: EventCommentMinAggregateInputType
    _max?: EventCommentMaxAggregateInputType
  }

  export type EventCommentGroupByOutputType = {
    id: string
    content: string
    userId: string
    eventId: string
    createdAt: Date
    _count: EventCommentCountAggregateOutputType | null
    _min: EventCommentMinAggregateOutputType | null
    _max: EventCommentMaxAggregateOutputType | null
  }

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


  export type EventCommentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    userId?: boolean
    eventId?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    event?: boolean | EventDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["eventComment"]>

  export type EventCommentSelectScalar = {
    id?: boolean
    content?: boolean
    userId?: boolean
    eventId?: boolean
    createdAt?: boolean
  }


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


  export type $EventCommentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "EventComment"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      event: Prisma.$EventPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      content: string
      userId: string
      eventId: string
      createdAt: Date
    }, ExtArgs["result"]["eventComment"]>
    composites: {}
  }


  type EventCommentGetPayload<S extends boolean | null | undefined | EventCommentDefaultArgs> = $Result.GetResult<Prisma.$EventCommentPayload, S>

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

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

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

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

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

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

    /**
     * Create a EventComment.
     * @param {EventCommentCreateArgs} args - Arguments to create a EventComment.
     * @example
     * // Create one EventComment
     * const EventComment = await prisma.eventComment.create({
     *   data: {
     *     // ... data to create a EventComment
     *   }
     * })
     * 
    **/
    create<T extends EventCommentCreateArgs<ExtArgs>>(
      args: SelectSubset<T, EventCommentCreateArgs<ExtArgs>>
    ): Prisma__EventCommentClient<$Result.GetResult<Prisma.$EventCommentPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a EventComment.
     * @param {EventCommentDeleteArgs} args - Arguments to delete one EventComment.
     * @example
     * // Delete one EventComment
     * const EventComment = await prisma.eventComment.delete({
     *   where: {
     *     // ... filter to delete one EventComment
     *   }
     * })
     * 
    **/
    delete<T extends EventCommentDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, EventCommentDeleteArgs<ExtArgs>>
    ): Prisma__EventCommentClient<$Result.GetResult<Prisma.$EventCommentPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one EventComment.
     * @param {EventCommentUpdateArgs} args - Arguments to update one EventComment.
     * @example
     * // Update one EventComment
     * const eventComment = await prisma.eventComment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends EventCommentUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, EventCommentUpdateArgs<ExtArgs>>
    ): Prisma__EventCommentClient<$Result.GetResult<Prisma.$EventCommentPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for EventComment.
   * 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__EventCommentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    event<T extends EventDefaultArgs<ExtArgs> = {}>(args?: Subset<T, EventDefaultArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<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 EventComment model
   */ 
  interface EventCommentFieldRefs {
    readonly id: FieldRef<"EventComment", 'String'>
    readonly content: FieldRef<"EventComment", 'String'>
    readonly userId: FieldRef<"EventComment", 'String'>
    readonly eventId: FieldRef<"EventComment", 'String'>
    readonly createdAt: FieldRef<"EventComment", 'DateTime'>
  }
    

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

  /**
   * EventComment findUniqueOrThrow
   */
  export type EventCommentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    /**
     * Filter, which EventComment to fetch.
     */
    where: EventCommentWhereUniqueInput
  }

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

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

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

  /**
   * EventComment create
   */
  export type EventCommentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    /**
     * The data needed to create a EventComment.
     */
    data: XOR<EventCommentCreateInput, EventCommentUncheckedCreateInput>
  }

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

  /**
   * EventComment update
   */
  export type EventCommentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    /**
     * The data needed to update a EventComment.
     */
    data: XOR<EventCommentUpdateInput, EventCommentUncheckedUpdateInput>
    /**
     * Choose, which EventComment to update.
     */
    where: EventCommentWhereUniqueInput
  }

  /**
   * EventComment updateMany
   */
  export type EventCommentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update EventComments.
     */
    data: XOR<EventCommentUpdateManyMutationInput, EventCommentUncheckedUpdateManyInput>
    /**
     * Filter which EventComments to update
     */
    where?: EventCommentWhereInput
  }

  /**
   * EventComment upsert
   */
  export type EventCommentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    /**
     * The filter to search for the EventComment to update in case it exists.
     */
    where: EventCommentWhereUniqueInput
    /**
     * In case the EventComment found by the `where` argument doesn't exist, create a new EventComment with this data.
     */
    create: XOR<EventCommentCreateInput, EventCommentUncheckedCreateInput>
    /**
     * In case the EventComment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EventCommentUpdateInput, EventCommentUncheckedUpdateInput>
  }

  /**
   * EventComment delete
   */
  export type EventCommentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventComment
     */
    select?: EventCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EventCommentInclude<ExtArgs> | null
    /**
     * Filter which EventComment to delete.
     */
    where: EventCommentWhereUniqueInput
  }

  /**
   * EventComment deleteMany
   */
  export type EventCommentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which EventComments to delete
     */
    where?: EventCommentWhereInput
  }

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


  /**
   * Model Appointment
   */

  export type AggregateAppointment = {
    _count: AppointmentCountAggregateOutputType | null
    _min: AppointmentMinAggregateOutputType | null
    _max: AppointmentMaxAggregateOutputType | null
  }

  export type AppointmentMinAggregateOutputType = {
    id: string | null
    title: string | null
    briefDescription: string | null
    description: string | null
    date: Date | null
    time: string | null
    activationDate: Date | null
    address: string | null
    active: boolean | null
  }

  export type AppointmentMaxAggregateOutputType = {
    id: string | null
    title: string | null
    briefDescription: string | null
    description: string | null
    date: Date | null
    time: string | null
    activationDate: Date | null
    address: string | null
    active: boolean | null
  }

  export type AppointmentCountAggregateOutputType = {
    id: number
    title: number
    briefDescription: number
    description: number
    date: number
    time: number
    activationDate: number
    address: number
    active: number
    images: number
    _all: number
  }


  export type AppointmentMinAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    time?: true
    activationDate?: true
    address?: true
    active?: true
  }

  export type AppointmentMaxAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    time?: true
    activationDate?: true
    address?: true
    active?: true
  }

  export type AppointmentCountAggregateInputType = {
    id?: true
    title?: true
    briefDescription?: true
    description?: true
    date?: true
    time?: true
    activationDate?: true
    address?: true
    active?: true
    images?: true
    _all?: true
  }

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

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




  export type AppointmentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithAggregationInput | AppointmentOrderByWithAggregationInput[]
    by: AppointmentScalarFieldEnum[] | AppointmentScalarFieldEnum
    having?: AppointmentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentCountAggregateInputType | true
    _min?: AppointmentMinAggregateInputType
    _max?: AppointmentMaxAggregateInputType
  }

  export type AppointmentGroupByOutputType = {
    id: string
    title: string
    briefDescription: string
    description: string
    date: Date
    time: string
    activationDate: Date
    address: string
    active: boolean
    images: string[]
    _count: AppointmentCountAggregateOutputType | null
    _min: AppointmentMinAggregateOutputType | null
    _max: AppointmentMaxAggregateOutputType | null
  }

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


  export type AppointmentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    briefDescription?: boolean
    description?: boolean
    date?: boolean
    time?: boolean
    activationDate?: boolean
    address?: boolean
    active?: boolean
    images?: boolean
    likes?: boolean | Appointment$likesArgs<ExtArgs>
    comments?: boolean | Appointment$commentsArgs<ExtArgs>
    registrations?: boolean | Appointment$registrationsArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>

  export type AppointmentSelectScalar = {
    id?: boolean
    title?: boolean
    briefDescription?: boolean
    description?: boolean
    date?: boolean
    time?: boolean
    activationDate?: boolean
    address?: boolean
    active?: boolean
    images?: boolean
  }


  export type AppointmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | Appointment$likesArgs<ExtArgs>
    comments?: boolean | Appointment$commentsArgs<ExtArgs>
    registrations?: boolean | Appointment$registrationsArgs<ExtArgs>
    _count?: boolean | AppointmentCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $AppointmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Appointment"
    objects: {
      likes: Prisma.$AppointmentLikePayload<ExtArgs>[]
      comments: Prisma.$AppointmentCommentPayload<ExtArgs>[]
      registrations: Prisma.$AppointmentRegistrationPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      briefDescription: string
      description: string
      date: Date
      time: string
      activationDate: Date
      address: string
      active: boolean
      images: string[]
    }, ExtArgs["result"]["appointment"]>
    composites: {}
  }


  type AppointmentGetPayload<S extends boolean | null | undefined | AppointmentDefaultArgs> = $Result.GetResult<Prisma.$AppointmentPayload, S>

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

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

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

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

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

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

    /**
     * Create a Appointment.
     * @param {AppointmentCreateArgs} args - Arguments to create a Appointment.
     * @example
     * // Create one Appointment
     * const Appointment = await prisma.appointment.create({
     *   data: {
     *     // ... data to create a Appointment
     *   }
     * })
     * 
    **/
    create<T extends AppointmentCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentCreateArgs<ExtArgs>>
    ): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Appointment.
     * @param {AppointmentDeleteArgs} args - Arguments to delete one Appointment.
     * @example
     * // Delete one Appointment
     * const Appointment = await prisma.appointment.delete({
     *   where: {
     *     // ... filter to delete one Appointment
     *   }
     * })
     * 
    **/
    delete<T extends AppointmentDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentDeleteArgs<ExtArgs>>
    ): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Appointment.
     * @param {AppointmentUpdateArgs} args - Arguments to update one Appointment.
     * @example
     * // Update one Appointment
     * const appointment = await prisma.appointment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AppointmentUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentUpdateArgs<ExtArgs>>
    ): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Appointment.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__AppointmentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    likes<T extends Appointment$likesArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$likesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentLikePayload<ExtArgs>, T, 'findMany'> | Null>;

    comments<T extends Appointment$commentsArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$commentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentCommentPayload<ExtArgs>, T, 'findMany'> | Null>;

    registrations<T extends Appointment$registrationsArgs<ExtArgs> = {}>(args?: Subset<T, Appointment$registrationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentRegistrationPayload<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 Appointment model
   */ 
  interface AppointmentFieldRefs {
    readonly id: FieldRef<"Appointment", 'String'>
    readonly title: FieldRef<"Appointment", 'String'>
    readonly briefDescription: FieldRef<"Appointment", 'String'>
    readonly description: FieldRef<"Appointment", 'String'>
    readonly date: FieldRef<"Appointment", 'DateTime'>
    readonly time: FieldRef<"Appointment", 'String'>
    readonly activationDate: FieldRef<"Appointment", 'DateTime'>
    readonly address: FieldRef<"Appointment", 'String'>
    readonly active: FieldRef<"Appointment", 'Boolean'>
    readonly images: FieldRef<"Appointment", 'String[]'>
  }
    

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

  /**
   * Appointment findUniqueOrThrow
   */
  export type AppointmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where: AppointmentWhereUniqueInput
  }

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

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

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

  /**
   * Appointment create
   */
  export type AppointmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to create a Appointment.
     */
    data: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
  }

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

  /**
   * Appointment update
   */
  export type AppointmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to update a Appointment.
     */
    data: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
    /**
     * Choose, which Appointment to update.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment updateMany
   */
  export type AppointmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Appointments.
     */
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyInput>
    /**
     * Filter which Appointments to update
     */
    where?: AppointmentWhereInput
  }

  /**
   * Appointment upsert
   */
  export type AppointmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The filter to search for the Appointment to update in case it exists.
     */
    where: AppointmentWhereUniqueInput
    /**
     * In case the Appointment found by the `where` argument doesn't exist, create a new Appointment with this data.
     */
    create: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
    /**
     * In case the Appointment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
  }

  /**
   * Appointment delete
   */
  export type AppointmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter which Appointment to delete.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment deleteMany
   */
  export type AppointmentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Appointments to delete
     */
    where?: AppointmentWhereInput
  }

  /**
   * Appointment.likes
   */
  export type Appointment$likesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    where?: AppointmentLikeWhereInput
    orderBy?: AppointmentLikeOrderByWithRelationInput | AppointmentLikeOrderByWithRelationInput[]
    cursor?: AppointmentLikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentLikeScalarFieldEnum | AppointmentLikeScalarFieldEnum[]
  }

  /**
   * Appointment.comments
   */
  export type Appointment$commentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    where?: AppointmentCommentWhereInput
    orderBy?: AppointmentCommentOrderByWithRelationInput | AppointmentCommentOrderByWithRelationInput[]
    cursor?: AppointmentCommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentCommentScalarFieldEnum | AppointmentCommentScalarFieldEnum[]
  }

  /**
   * Appointment.registrations
   */
  export type Appointment$registrationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    where?: AppointmentRegistrationWhereInput
    orderBy?: AppointmentRegistrationOrderByWithRelationInput | AppointmentRegistrationOrderByWithRelationInput[]
    cursor?: AppointmentRegistrationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentRegistrationScalarFieldEnum | AppointmentRegistrationScalarFieldEnum[]
  }

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


  /**
   * Model AppointmentLike
   */

  export type AggregateAppointmentLike = {
    _count: AppointmentLikeCountAggregateOutputType | null
    _min: AppointmentLikeMinAggregateOutputType | null
    _max: AppointmentLikeMaxAggregateOutputType | null
  }

  export type AppointmentLikeMinAggregateOutputType = {
    id: string | null
    userId: string | null
    appointmentId: string | null
  }

  export type AppointmentLikeMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    appointmentId: string | null
  }

  export type AppointmentLikeCountAggregateOutputType = {
    id: number
    userId: number
    appointmentId: number
    _all: number
  }


  export type AppointmentLikeMinAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
  }

  export type AppointmentLikeMaxAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
  }

  export type AppointmentLikeCountAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
    _all?: true
  }

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

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




  export type AppointmentLikeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentLikeWhereInput
    orderBy?: AppointmentLikeOrderByWithAggregationInput | AppointmentLikeOrderByWithAggregationInput[]
    by: AppointmentLikeScalarFieldEnum[] | AppointmentLikeScalarFieldEnum
    having?: AppointmentLikeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentLikeCountAggregateInputType | true
    _min?: AppointmentLikeMinAggregateInputType
    _max?: AppointmentLikeMaxAggregateInputType
  }

  export type AppointmentLikeGroupByOutputType = {
    id: string
    userId: string
    appointmentId: string
    _count: AppointmentLikeCountAggregateOutputType | null
    _min: AppointmentLikeMinAggregateOutputType | null
    _max: AppointmentLikeMaxAggregateOutputType | null
  }

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


  export type AppointmentLikeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    appointmentId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentLike"]>

  export type AppointmentLikeSelectScalar = {
    id?: boolean
    userId?: boolean
    appointmentId?: boolean
  }


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


  export type $AppointmentLikePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentLike"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      appointment: Prisma.$AppointmentPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      appointmentId: string
    }, ExtArgs["result"]["appointmentLike"]>
    composites: {}
  }


  type AppointmentLikeGetPayload<S extends boolean | null | undefined | AppointmentLikeDefaultArgs> = $Result.GetResult<Prisma.$AppointmentLikePayload, S>

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

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

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

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

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

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

    /**
     * Create a AppointmentLike.
     * @param {AppointmentLikeCreateArgs} args - Arguments to create a AppointmentLike.
     * @example
     * // Create one AppointmentLike
     * const AppointmentLike = await prisma.appointmentLike.create({
     *   data: {
     *     // ... data to create a AppointmentLike
     *   }
     * })
     * 
    **/
    create<T extends AppointmentLikeCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentLikeCreateArgs<ExtArgs>>
    ): Prisma__AppointmentLikeClient<$Result.GetResult<Prisma.$AppointmentLikePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a AppointmentLike.
     * @param {AppointmentLikeDeleteArgs} args - Arguments to delete one AppointmentLike.
     * @example
     * // Delete one AppointmentLike
     * const AppointmentLike = await prisma.appointmentLike.delete({
     *   where: {
     *     // ... filter to delete one AppointmentLike
     *   }
     * })
     * 
    **/
    delete<T extends AppointmentLikeDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentLikeDeleteArgs<ExtArgs>>
    ): Prisma__AppointmentLikeClient<$Result.GetResult<Prisma.$AppointmentLikePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one AppointmentLike.
     * @param {AppointmentLikeUpdateArgs} args - Arguments to update one AppointmentLike.
     * @example
     * // Update one AppointmentLike
     * const appointmentLike = await prisma.appointmentLike.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AppointmentLikeUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentLikeUpdateArgs<ExtArgs>>
    ): Prisma__AppointmentLikeClient<$Result.GetResult<Prisma.$AppointmentLikePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppointmentLike.
   * 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__AppointmentLikeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<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 AppointmentLike model
   */ 
  interface AppointmentLikeFieldRefs {
    readonly id: FieldRef<"AppointmentLike", 'String'>
    readonly userId: FieldRef<"AppointmentLike", 'String'>
    readonly appointmentId: FieldRef<"AppointmentLike", 'String'>
  }
    

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

  /**
   * AppointmentLike findUniqueOrThrow
   */
  export type AppointmentLikeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentLike to fetch.
     */
    where: AppointmentLikeWhereUniqueInput
  }

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

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

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

  /**
   * AppointmentLike create
   */
  export type AppointmentLikeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    /**
     * The data needed to create a AppointmentLike.
     */
    data: XOR<AppointmentLikeCreateInput, AppointmentLikeUncheckedCreateInput>
  }

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

  /**
   * AppointmentLike update
   */
  export type AppointmentLikeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    /**
     * The data needed to update a AppointmentLike.
     */
    data: XOR<AppointmentLikeUpdateInput, AppointmentLikeUncheckedUpdateInput>
    /**
     * Choose, which AppointmentLike to update.
     */
    where: AppointmentLikeWhereUniqueInput
  }

  /**
   * AppointmentLike updateMany
   */
  export type AppointmentLikeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppointmentLikes.
     */
    data: XOR<AppointmentLikeUpdateManyMutationInput, AppointmentLikeUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentLikes to update
     */
    where?: AppointmentLikeWhereInput
  }

  /**
   * AppointmentLike upsert
   */
  export type AppointmentLikeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    /**
     * The filter to search for the AppointmentLike to update in case it exists.
     */
    where: AppointmentLikeWhereUniqueInput
    /**
     * In case the AppointmentLike found by the `where` argument doesn't exist, create a new AppointmentLike with this data.
     */
    create: XOR<AppointmentLikeCreateInput, AppointmentLikeUncheckedCreateInput>
    /**
     * In case the AppointmentLike was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentLikeUpdateInput, AppointmentLikeUncheckedUpdateInput>
  }

  /**
   * AppointmentLike delete
   */
  export type AppointmentLikeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentLike
     */
    select?: AppointmentLikeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentLikeInclude<ExtArgs> | null
    /**
     * Filter which AppointmentLike to delete.
     */
    where: AppointmentLikeWhereUniqueInput
  }

  /**
   * AppointmentLike deleteMany
   */
  export type AppointmentLikeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentLikes to delete
     */
    where?: AppointmentLikeWhereInput
  }

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


  /**
   * Model AppointmentComment
   */

  export type AggregateAppointmentComment = {
    _count: AppointmentCommentCountAggregateOutputType | null
    _min: AppointmentCommentMinAggregateOutputType | null
    _max: AppointmentCommentMaxAggregateOutputType | null
  }

  export type AppointmentCommentMinAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    appointmentId: string | null
    createdAt: Date | null
  }

  export type AppointmentCommentMaxAggregateOutputType = {
    id: string | null
    content: string | null
    userId: string | null
    appointmentId: string | null
    createdAt: Date | null
  }

  export type AppointmentCommentCountAggregateOutputType = {
    id: number
    content: number
    userId: number
    appointmentId: number
    createdAt: number
    _all: number
  }


  export type AppointmentCommentMinAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
  }

  export type AppointmentCommentMaxAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
  }

  export type AppointmentCommentCountAggregateInputType = {
    id?: true
    content?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type AppointmentCommentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentCommentWhereInput
    orderBy?: AppointmentCommentOrderByWithAggregationInput | AppointmentCommentOrderByWithAggregationInput[]
    by: AppointmentCommentScalarFieldEnum[] | AppointmentCommentScalarFieldEnum
    having?: AppointmentCommentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentCommentCountAggregateInputType | true
    _min?: AppointmentCommentMinAggregateInputType
    _max?: AppointmentCommentMaxAggregateInputType
  }

  export type AppointmentCommentGroupByOutputType = {
    id: string
    content: string
    userId: string
    appointmentId: string
    createdAt: Date
    _count: AppointmentCommentCountAggregateOutputType | null
    _min: AppointmentCommentMinAggregateOutputType | null
    _max: AppointmentCommentMaxAggregateOutputType | null
  }

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


  export type AppointmentCommentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    content?: boolean
    userId?: boolean
    appointmentId?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentComment"]>

  export type AppointmentCommentSelectScalar = {
    id?: boolean
    content?: boolean
    userId?: boolean
    appointmentId?: boolean
    createdAt?: boolean
  }


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


  export type $AppointmentCommentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentComment"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      appointment: Prisma.$AppointmentPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      content: string
      userId: string
      appointmentId: string
      createdAt: Date
    }, ExtArgs["result"]["appointmentComment"]>
    composites: {}
  }


  type AppointmentCommentGetPayload<S extends boolean | null | undefined | AppointmentCommentDefaultArgs> = $Result.GetResult<Prisma.$AppointmentCommentPayload, S>

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

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

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

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

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

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

    /**
     * Create a AppointmentComment.
     * @param {AppointmentCommentCreateArgs} args - Arguments to create a AppointmentComment.
     * @example
     * // Create one AppointmentComment
     * const AppointmentComment = await prisma.appointmentComment.create({
     *   data: {
     *     // ... data to create a AppointmentComment
     *   }
     * })
     * 
    **/
    create<T extends AppointmentCommentCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentCommentCreateArgs<ExtArgs>>
    ): Prisma__AppointmentCommentClient<$Result.GetResult<Prisma.$AppointmentCommentPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a AppointmentComment.
     * @param {AppointmentCommentDeleteArgs} args - Arguments to delete one AppointmentComment.
     * @example
     * // Delete one AppointmentComment
     * const AppointmentComment = await prisma.appointmentComment.delete({
     *   where: {
     *     // ... filter to delete one AppointmentComment
     *   }
     * })
     * 
    **/
    delete<T extends AppointmentCommentDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentCommentDeleteArgs<ExtArgs>>
    ): Prisma__AppointmentCommentClient<$Result.GetResult<Prisma.$AppointmentCommentPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one AppointmentComment.
     * @param {AppointmentCommentUpdateArgs} args - Arguments to update one AppointmentComment.
     * @example
     * // Update one AppointmentComment
     * const appointmentComment = await prisma.appointmentComment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AppointmentCommentUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentCommentUpdateArgs<ExtArgs>>
    ): Prisma__AppointmentCommentClient<$Result.GetResult<Prisma.$AppointmentCommentPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppointmentComment.
   * 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__AppointmentCommentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<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 AppointmentComment model
   */ 
  interface AppointmentCommentFieldRefs {
    readonly id: FieldRef<"AppointmentComment", 'String'>
    readonly content: FieldRef<"AppointmentComment", 'String'>
    readonly userId: FieldRef<"AppointmentComment", 'String'>
    readonly appointmentId: FieldRef<"AppointmentComment", 'String'>
    readonly createdAt: FieldRef<"AppointmentComment", 'DateTime'>
  }
    

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

  /**
   * AppointmentComment findUniqueOrThrow
   */
  export type AppointmentCommentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentComment to fetch.
     */
    where: AppointmentCommentWhereUniqueInput
  }

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

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

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

  /**
   * AppointmentComment create
   */
  export type AppointmentCommentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    /**
     * The data needed to create a AppointmentComment.
     */
    data: XOR<AppointmentCommentCreateInput, AppointmentCommentUncheckedCreateInput>
  }

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

  /**
   * AppointmentComment update
   */
  export type AppointmentCommentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    /**
     * The data needed to update a AppointmentComment.
     */
    data: XOR<AppointmentCommentUpdateInput, AppointmentCommentUncheckedUpdateInput>
    /**
     * Choose, which AppointmentComment to update.
     */
    where: AppointmentCommentWhereUniqueInput
  }

  /**
   * AppointmentComment updateMany
   */
  export type AppointmentCommentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppointmentComments.
     */
    data: XOR<AppointmentCommentUpdateManyMutationInput, AppointmentCommentUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentComments to update
     */
    where?: AppointmentCommentWhereInput
  }

  /**
   * AppointmentComment upsert
   */
  export type AppointmentCommentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    /**
     * The filter to search for the AppointmentComment to update in case it exists.
     */
    where: AppointmentCommentWhereUniqueInput
    /**
     * In case the AppointmentComment found by the `where` argument doesn't exist, create a new AppointmentComment with this data.
     */
    create: XOR<AppointmentCommentCreateInput, AppointmentCommentUncheckedCreateInput>
    /**
     * In case the AppointmentComment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentCommentUpdateInput, AppointmentCommentUncheckedUpdateInput>
  }

  /**
   * AppointmentComment delete
   */
  export type AppointmentCommentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentComment
     */
    select?: AppointmentCommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentCommentInclude<ExtArgs> | null
    /**
     * Filter which AppointmentComment to delete.
     */
    where: AppointmentCommentWhereUniqueInput
  }

  /**
   * AppointmentComment deleteMany
   */
  export type AppointmentCommentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentComments to delete
     */
    where?: AppointmentCommentWhereInput
  }

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


  /**
   * Model AppointmentRegistration
   */

  export type AggregateAppointmentRegistration = {
    _count: AppointmentRegistrationCountAggregateOutputType | null
    _min: AppointmentRegistrationMinAggregateOutputType | null
    _max: AppointmentRegistrationMaxAggregateOutputType | null
  }

  export type AppointmentRegistrationMinAggregateOutputType = {
    id: string | null
    userId: string | null
    appointmentId: string | null
    createdAt: Date | null
  }

  export type AppointmentRegistrationMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    appointmentId: string | null
    createdAt: Date | null
  }

  export type AppointmentRegistrationCountAggregateOutputType = {
    id: number
    userId: number
    appointmentId: number
    createdAt: number
    _all: number
  }


  export type AppointmentRegistrationMinAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
  }

  export type AppointmentRegistrationMaxAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
  }

  export type AppointmentRegistrationCountAggregateInputType = {
    id?: true
    userId?: true
    appointmentId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type AppointmentRegistrationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentRegistrationWhereInput
    orderBy?: AppointmentRegistrationOrderByWithAggregationInput | AppointmentRegistrationOrderByWithAggregationInput[]
    by: AppointmentRegistrationScalarFieldEnum[] | AppointmentRegistrationScalarFieldEnum
    having?: AppointmentRegistrationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentRegistrationCountAggregateInputType | true
    _min?: AppointmentRegistrationMinAggregateInputType
    _max?: AppointmentRegistrationMaxAggregateInputType
  }

  export type AppointmentRegistrationGroupByOutputType = {
    id: string
    userId: string
    appointmentId: string
    createdAt: Date
    _count: AppointmentRegistrationCountAggregateOutputType | null
    _min: AppointmentRegistrationMinAggregateOutputType | null
    _max: AppointmentRegistrationMaxAggregateOutputType | null
  }

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


  export type AppointmentRegistrationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    appointmentId?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    appointment?: boolean | AppointmentDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointmentRegistration"]>

  export type AppointmentRegistrationSelectScalar = {
    id?: boolean
    userId?: boolean
    appointmentId?: boolean
    createdAt?: boolean
  }


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


  export type $AppointmentRegistrationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppointmentRegistration"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      appointment: Prisma.$AppointmentPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      appointmentId: string
      createdAt: Date
    }, ExtArgs["result"]["appointmentRegistration"]>
    composites: {}
  }


  type AppointmentRegistrationGetPayload<S extends boolean | null | undefined | AppointmentRegistrationDefaultArgs> = $Result.GetResult<Prisma.$AppointmentRegistrationPayload, S>

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

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

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

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

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

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

    /**
     * Create a AppointmentRegistration.
     * @param {AppointmentRegistrationCreateArgs} args - Arguments to create a AppointmentRegistration.
     * @example
     * // Create one AppointmentRegistration
     * const AppointmentRegistration = await prisma.appointmentRegistration.create({
     *   data: {
     *     // ... data to create a AppointmentRegistration
     *   }
     * })
     * 
    **/
    create<T extends AppointmentRegistrationCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentRegistrationCreateArgs<ExtArgs>>
    ): Prisma__AppointmentRegistrationClient<$Result.GetResult<Prisma.$AppointmentRegistrationPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a AppointmentRegistration.
     * @param {AppointmentRegistrationDeleteArgs} args - Arguments to delete one AppointmentRegistration.
     * @example
     * // Delete one AppointmentRegistration
     * const AppointmentRegistration = await prisma.appointmentRegistration.delete({
     *   where: {
     *     // ... filter to delete one AppointmentRegistration
     *   }
     * })
     * 
    **/
    delete<T extends AppointmentRegistrationDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentRegistrationDeleteArgs<ExtArgs>>
    ): Prisma__AppointmentRegistrationClient<$Result.GetResult<Prisma.$AppointmentRegistrationPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one AppointmentRegistration.
     * @param {AppointmentRegistrationUpdateArgs} args - Arguments to update one AppointmentRegistration.
     * @example
     * // Update one AppointmentRegistration
     * const appointmentRegistration = await prisma.appointmentRegistration.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AppointmentRegistrationUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AppointmentRegistrationUpdateArgs<ExtArgs>>
    ): Prisma__AppointmentRegistrationClient<$Result.GetResult<Prisma.$AppointmentRegistrationPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppointmentRegistration.
   * 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__AppointmentRegistrationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, 'findUniqueOrThrow'> | Null, Null, ExtArgs>;

    appointment<T extends AppointmentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AppointmentDefaultArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<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 AppointmentRegistration model
   */ 
  interface AppointmentRegistrationFieldRefs {
    readonly id: FieldRef<"AppointmentRegistration", 'String'>
    readonly userId: FieldRef<"AppointmentRegistration", 'String'>
    readonly appointmentId: FieldRef<"AppointmentRegistration", 'String'>
    readonly createdAt: FieldRef<"AppointmentRegistration", 'DateTime'>
  }
    

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

  /**
   * AppointmentRegistration findUniqueOrThrow
   */
  export type AppointmentRegistrationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    /**
     * Filter, which AppointmentRegistration to fetch.
     */
    where: AppointmentRegistrationWhereUniqueInput
  }

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

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

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

  /**
   * AppointmentRegistration create
   */
  export type AppointmentRegistrationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    /**
     * The data needed to create a AppointmentRegistration.
     */
    data: XOR<AppointmentRegistrationCreateInput, AppointmentRegistrationUncheckedCreateInput>
  }

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

  /**
   * AppointmentRegistration update
   */
  export type AppointmentRegistrationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    /**
     * The data needed to update a AppointmentRegistration.
     */
    data: XOR<AppointmentRegistrationUpdateInput, AppointmentRegistrationUncheckedUpdateInput>
    /**
     * Choose, which AppointmentRegistration to update.
     */
    where: AppointmentRegistrationWhereUniqueInput
  }

  /**
   * AppointmentRegistration updateMany
   */
  export type AppointmentRegistrationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppointmentRegistrations.
     */
    data: XOR<AppointmentRegistrationUpdateManyMutationInput, AppointmentRegistrationUncheckedUpdateManyInput>
    /**
     * Filter which AppointmentRegistrations to update
     */
    where?: AppointmentRegistrationWhereInput
  }

  /**
   * AppointmentRegistration upsert
   */
  export type AppointmentRegistrationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    /**
     * The filter to search for the AppointmentRegistration to update in case it exists.
     */
    where: AppointmentRegistrationWhereUniqueInput
    /**
     * In case the AppointmentRegistration found by the `where` argument doesn't exist, create a new AppointmentRegistration with this data.
     */
    create: XOR<AppointmentRegistrationCreateInput, AppointmentRegistrationUncheckedCreateInput>
    /**
     * In case the AppointmentRegistration was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentRegistrationUpdateInput, AppointmentRegistrationUncheckedUpdateInput>
  }

  /**
   * AppointmentRegistration delete
   */
  export type AppointmentRegistrationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppointmentRegistration
     */
    select?: AppointmentRegistrationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentRegistrationInclude<ExtArgs> | null
    /**
     * Filter which AppointmentRegistration to delete.
     */
    where: AppointmentRegistrationWhereUniqueInput
  }

  /**
   * AppointmentRegistration deleteMany
   */
  export type AppointmentRegistrationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppointmentRegistrations to delete
     */
    where?: AppointmentRegistrationWhereInput
  }

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


  /**
   * Model Album
   */

  export type AggregateAlbum = {
    _count: AlbumCountAggregateOutputType | null
    _min: AlbumMinAggregateOutputType | null
    _max: AlbumMaxAggregateOutputType | null
  }

  export type AlbumMinAggregateOutputType = {
    id: string | null
    title: string | null
    date: Date | null
  }

  export type AlbumMaxAggregateOutputType = {
    id: string | null
    title: string | null
    date: Date | null
  }

  export type AlbumCountAggregateOutputType = {
    id: number
    title: number
    date: number
    images: number
    _all: number
  }


  export type AlbumMinAggregateInputType = {
    id?: true
    title?: true
    date?: true
  }

  export type AlbumMaxAggregateInputType = {
    id?: true
    title?: true
    date?: true
  }

  export type AlbumCountAggregateInputType = {
    id?: true
    title?: true
    date?: true
    images?: true
    _all?: true
  }

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

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




  export type AlbumGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AlbumWhereInput
    orderBy?: AlbumOrderByWithAggregationInput | AlbumOrderByWithAggregationInput[]
    by: AlbumScalarFieldEnum[] | AlbumScalarFieldEnum
    having?: AlbumScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AlbumCountAggregateInputType | true
    _min?: AlbumMinAggregateInputType
    _max?: AlbumMaxAggregateInputType
  }

  export type AlbumGroupByOutputType = {
    id: string
    title: string
    date: Date
    images: string[]
    _count: AlbumCountAggregateOutputType | null
    _min: AlbumMinAggregateOutputType | null
    _max: AlbumMaxAggregateOutputType | null
  }

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


  export type AlbumSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    date?: boolean
    images?: boolean
  }, ExtArgs["result"]["album"]>

  export type AlbumSelectScalar = {
    id?: boolean
    title?: boolean
    date?: boolean
    images?: boolean
  }



  export type $AlbumPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Album"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      date: Date
      images: string[]
    }, ExtArgs["result"]["album"]>
    composites: {}
  }


  type AlbumGetPayload<S extends boolean | null | undefined | AlbumDefaultArgs> = $Result.GetResult<Prisma.$AlbumPayload, S>

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

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

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

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

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

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

    /**
     * Create a Album.
     * @param {AlbumCreateArgs} args - Arguments to create a Album.
     * @example
     * // Create one Album
     * const Album = await prisma.album.create({
     *   data: {
     *     // ... data to create a Album
     *   }
     * })
     * 
    **/
    create<T extends AlbumCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AlbumCreateArgs<ExtArgs>>
    ): Prisma__AlbumClient<$Result.GetResult<Prisma.$AlbumPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Album.
     * @param {AlbumDeleteArgs} args - Arguments to delete one Album.
     * @example
     * // Delete one Album
     * const Album = await prisma.album.delete({
     *   where: {
     *     // ... filter to delete one Album
     *   }
     * })
     * 
    **/
    delete<T extends AlbumDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AlbumDeleteArgs<ExtArgs>>
    ): Prisma__AlbumClient<$Result.GetResult<Prisma.$AlbumPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Album.
     * @param {AlbumUpdateArgs} args - Arguments to update one Album.
     * @example
     * // Update one Album
     * const album = await prisma.album.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AlbumUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AlbumUpdateArgs<ExtArgs>>
    ): Prisma__AlbumClient<$Result.GetResult<Prisma.$AlbumPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Album.
   * 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__AlbumClient<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 Album model
   */ 
  interface AlbumFieldRefs {
    readonly id: FieldRef<"Album", 'String'>
    readonly title: FieldRef<"Album", 'String'>
    readonly date: FieldRef<"Album", 'DateTime'>
    readonly images: FieldRef<"Album", 'String[]'>
  }
    

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

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

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

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

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

  /**
   * Album create
   */
  export type AlbumCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Album
     */
    select?: AlbumSelect<ExtArgs> | null
    /**
     * The data needed to create a Album.
     */
    data: XOR<AlbumCreateInput, AlbumUncheckedCreateInput>
  }

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

  /**
   * Album update
   */
  export type AlbumUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Album
     */
    select?: AlbumSelect<ExtArgs> | null
    /**
     * The data needed to update a Album.
     */
    data: XOR<AlbumUpdateInput, AlbumUncheckedUpdateInput>
    /**
     * Choose, which Album to update.
     */
    where: AlbumWhereUniqueInput
  }

  /**
   * Album updateMany
   */
  export type AlbumUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Albums.
     */
    data: XOR<AlbumUpdateManyMutationInput, AlbumUncheckedUpdateManyInput>
    /**
     * Filter which Albums to update
     */
    where?: AlbumWhereInput
  }

  /**
   * Album upsert
   */
  export type AlbumUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Album
     */
    select?: AlbumSelect<ExtArgs> | null
    /**
     * The filter to search for the Album to update in case it exists.
     */
    where: AlbumWhereUniqueInput
    /**
     * In case the Album found by the `where` argument doesn't exist, create a new Album with this data.
     */
    create: XOR<AlbumCreateInput, AlbumUncheckedCreateInput>
    /**
     * In case the Album was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AlbumUpdateInput, AlbumUncheckedUpdateInput>
  }

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

  /**
   * Album deleteMany
   */
  export type AlbumDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Albums to delete
     */
    where?: AlbumWhereInput
  }

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


  /**
   * Model Video
   */

  export type AggregateVideo = {
    _count: VideoCountAggregateOutputType | null
    _min: VideoMinAggregateOutputType | null
    _max: VideoMaxAggregateOutputType | null
  }

  export type VideoMinAggregateOutputType = {
    id: string | null
    title: string | null
    date: Date | null
    link: string | null
  }

  export type VideoMaxAggregateOutputType = {
    id: string | null
    title: string | null
    date: Date | null
    link: string | null
  }

  export type VideoCountAggregateOutputType = {
    id: number
    title: number
    date: number
    link: number
    _all: number
  }


  export type VideoMinAggregateInputType = {
    id?: true
    title?: true
    date?: true
    link?: true
  }

  export type VideoMaxAggregateInputType = {
    id?: true
    title?: true
    date?: true
    link?: true
  }

  export type VideoCountAggregateInputType = {
    id?: true
    title?: true
    date?: true
    link?: true
    _all?: true
  }

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

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




  export type VideoGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VideoWhereInput
    orderBy?: VideoOrderByWithAggregationInput | VideoOrderByWithAggregationInput[]
    by: VideoScalarFieldEnum[] | VideoScalarFieldEnum
    having?: VideoScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VideoCountAggregateInputType | true
    _min?: VideoMinAggregateInputType
    _max?: VideoMaxAggregateInputType
  }

  export type VideoGroupByOutputType = {
    id: string
    title: string
    date: Date
    link: string
    _count: VideoCountAggregateOutputType | null
    _min: VideoMinAggregateOutputType | null
    _max: VideoMaxAggregateOutputType | null
  }

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


  export type VideoSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    date?: boolean
    link?: boolean
  }, ExtArgs["result"]["video"]>

  export type VideoSelectScalar = {
    id?: boolean
    title?: boolean
    date?: boolean
    link?: boolean
  }



  export type $VideoPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Video"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      date: Date
      link: string
    }, ExtArgs["result"]["video"]>
    composites: {}
  }


  type VideoGetPayload<S extends boolean | null | undefined | VideoDefaultArgs> = $Result.GetResult<Prisma.$VideoPayload, S>

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

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

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

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

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

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

    /**
     * Create a Video.
     * @param {VideoCreateArgs} args - Arguments to create a Video.
     * @example
     * // Create one Video
     * const Video = await prisma.video.create({
     *   data: {
     *     // ... data to create a Video
     *   }
     * })
     * 
    **/
    create<T extends VideoCreateArgs<ExtArgs>>(
      args: SelectSubset<T, VideoCreateArgs<ExtArgs>>
    ): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Video.
     * @param {VideoDeleteArgs} args - Arguments to delete one Video.
     * @example
     * // Delete one Video
     * const Video = await prisma.video.delete({
     *   where: {
     *     // ... filter to delete one Video
     *   }
     * })
     * 
    **/
    delete<T extends VideoDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, VideoDeleteArgs<ExtArgs>>
    ): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Video.
     * @param {VideoUpdateArgs} args - Arguments to update one Video.
     * @example
     * // Update one Video
     * const video = await prisma.video.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends VideoUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, VideoUpdateArgs<ExtArgs>>
    ): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Video.
   * 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__VideoClient<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 Video model
   */ 
  interface VideoFieldRefs {
    readonly id: FieldRef<"Video", 'String'>
    readonly title: FieldRef<"Video", 'String'>
    readonly date: FieldRef<"Video", 'DateTime'>
    readonly link: FieldRef<"Video", 'String'>
  }
    

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

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

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

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

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

  /**
   * Video create
   */
  export type VideoCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * The data needed to create a Video.
     */
    data: XOR<VideoCreateInput, VideoUncheckedCreateInput>
  }

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

  /**
   * Video update
   */
  export type VideoUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * The data needed to update a Video.
     */
    data: XOR<VideoUpdateInput, VideoUncheckedUpdateInput>
    /**
     * Choose, which Video to update.
     */
    where: VideoWhereUniqueInput
  }

  /**
   * Video updateMany
   */
  export type VideoUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Videos.
     */
    data: XOR<VideoUpdateManyMutationInput, VideoUncheckedUpdateManyInput>
    /**
     * Filter which Videos to update
     */
    where?: VideoWhereInput
  }

  /**
   * Video upsert
   */
  export type VideoUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * The filter to search for the Video to update in case it exists.
     */
    where: VideoWhereUniqueInput
    /**
     * In case the Video found by the `where` argument doesn't exist, create a new Video with this data.
     */
    create: XOR<VideoCreateInput, VideoUncheckedCreateInput>
    /**
     * In case the Video was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VideoUpdateInput, VideoUncheckedUpdateInput>
  }

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

  /**
   * Video deleteMany
   */
  export type VideoDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Videos to delete
     */
    where?: VideoWhereInput
  }

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


  /**
   * Model Edition
   */

  export type AggregateEdition = {
    _count: EditionCountAggregateOutputType | null
    _min: EditionMinAggregateOutputType | null
    _max: EditionMaxAggregateOutputType | null
  }

  export type EditionMinAggregateOutputType = {
    id: string | null
    title: string | null
    categoryId: string | null
    document: string | null
    image: string | null
  }

  export type EditionMaxAggregateOutputType = {
    id: string | null
    title: string | null
    categoryId: string | null
    document: string | null
    image: string | null
  }

  export type EditionCountAggregateOutputType = {
    id: number
    title: number
    categoryId: number
    document: number
    image: number
    _all: number
  }


  export type EditionMinAggregateInputType = {
    id?: true
    title?: true
    categoryId?: true
    document?: true
    image?: true
  }

  export type EditionMaxAggregateInputType = {
    id?: true
    title?: true
    categoryId?: true
    document?: true
    image?: true
  }

  export type EditionCountAggregateInputType = {
    id?: true
    title?: true
    categoryId?: true
    document?: true
    image?: true
    _all?: true
  }

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

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




  export type EditionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EditionWhereInput
    orderBy?: EditionOrderByWithAggregationInput | EditionOrderByWithAggregationInput[]
    by: EditionScalarFieldEnum[] | EditionScalarFieldEnum
    having?: EditionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EditionCountAggregateInputType | true
    _min?: EditionMinAggregateInputType
    _max?: EditionMaxAggregateInputType
  }

  export type EditionGroupByOutputType = {
    id: string
    title: string
    categoryId: string
    document: string
    image: string | null
    _count: EditionCountAggregateOutputType | null
    _min: EditionMinAggregateOutputType | null
    _max: EditionMaxAggregateOutputType | null
  }

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


  export type EditionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    categoryId?: boolean
    document?: boolean
    image?: boolean
    category?: boolean | CategoryDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["edition"]>

  export type EditionSelectScalar = {
    id?: boolean
    title?: boolean
    categoryId?: boolean
    document?: boolean
    image?: boolean
  }


  export type EditionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    category?: boolean | CategoryDefaultArgs<ExtArgs>
  }


  export type $EditionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Edition"
    objects: {
      category: Prisma.$CategoryPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      categoryId: string
      document: string
      image: string | null
    }, ExtArgs["result"]["edition"]>
    composites: {}
  }


  type EditionGetPayload<S extends boolean | null | undefined | EditionDefaultArgs> = $Result.GetResult<Prisma.$EditionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Edition.
     * @param {EditionCreateArgs} args - Arguments to create a Edition.
     * @example
     * // Create one Edition
     * const Edition = await prisma.edition.create({
     *   data: {
     *     // ... data to create a Edition
     *   }
     * })
     * 
    **/
    create<T extends EditionCreateArgs<ExtArgs>>(
      args: SelectSubset<T, EditionCreateArgs<ExtArgs>>
    ): Prisma__EditionClient<$Result.GetResult<Prisma.$EditionPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Edition.
     * @param {EditionDeleteArgs} args - Arguments to delete one Edition.
     * @example
     * // Delete one Edition
     * const Edition = await prisma.edition.delete({
     *   where: {
     *     // ... filter to delete one Edition
     *   }
     * })
     * 
    **/
    delete<T extends EditionDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, EditionDeleteArgs<ExtArgs>>
    ): Prisma__EditionClient<$Result.GetResult<Prisma.$EditionPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Edition.
     * @param {EditionUpdateArgs} args - Arguments to update one Edition.
     * @example
     * // Update one Edition
     * const edition = await prisma.edition.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends EditionUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, EditionUpdateArgs<ExtArgs>>
    ): Prisma__EditionClient<$Result.GetResult<Prisma.$EditionPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Edition.
   * 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__EditionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    category<T extends CategoryDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CategoryDefaultArgs<ExtArgs>>): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<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 Edition model
   */ 
  interface EditionFieldRefs {
    readonly id: FieldRef<"Edition", 'String'>
    readonly title: FieldRef<"Edition", 'String'>
    readonly categoryId: FieldRef<"Edition", 'String'>
    readonly document: FieldRef<"Edition", 'String'>
    readonly image: FieldRef<"Edition", 'String'>
  }
    

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

  /**
   * Edition findUniqueOrThrow
   */
  export type EditionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    /**
     * Filter, which Edition to fetch.
     */
    where: EditionWhereUniqueInput
  }

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

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

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

  /**
   * Edition create
   */
  export type EditionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    /**
     * The data needed to create a Edition.
     */
    data: XOR<EditionCreateInput, EditionUncheckedCreateInput>
  }

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

  /**
   * Edition update
   */
  export type EditionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    /**
     * The data needed to update a Edition.
     */
    data: XOR<EditionUpdateInput, EditionUncheckedUpdateInput>
    /**
     * Choose, which Edition to update.
     */
    where: EditionWhereUniqueInput
  }

  /**
   * Edition updateMany
   */
  export type EditionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Editions.
     */
    data: XOR<EditionUpdateManyMutationInput, EditionUncheckedUpdateManyInput>
    /**
     * Filter which Editions to update
     */
    where?: EditionWhereInput
  }

  /**
   * Edition upsert
   */
  export type EditionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    /**
     * The filter to search for the Edition to update in case it exists.
     */
    where: EditionWhereUniqueInput
    /**
     * In case the Edition found by the `where` argument doesn't exist, create a new Edition with this data.
     */
    create: XOR<EditionCreateInput, EditionUncheckedCreateInput>
    /**
     * In case the Edition was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EditionUpdateInput, EditionUncheckedUpdateInput>
  }

  /**
   * Edition delete
   */
  export type EditionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Edition
     */
    select?: EditionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EditionInclude<ExtArgs> | null
    /**
     * Filter which Edition to delete.
     */
    where: EditionWhereUniqueInput
  }

  /**
   * Edition deleteMany
   */
  export type EditionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Editions to delete
     */
    where?: EditionWhereInput
  }

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


  /**
   * Model Training
   */

  export type AggregateTraining = {
    _count: TrainingCountAggregateOutputType | null
    _min: TrainingMinAggregateOutputType | null
    _max: TrainingMaxAggregateOutputType | null
  }

  export type TrainingMinAggregateOutputType = {
    id: string | null
    title: string | null
    place: string | null
    date: Date | null
    email: string | null
    phoneNumber: string | null
    website: string | null
    type: $Enums.TrainingType | null
    description: string | null
    document: string | null
  }

  export type TrainingMaxAggregateOutputType = {
    id: string | null
    title: string | null
    place: string | null
    date: Date | null
    email: string | null
    phoneNumber: string | null
    website: string | null
    type: $Enums.TrainingType | null
    description: string | null
    document: string | null
  }

  export type TrainingCountAggregateOutputType = {
    id: number
    title: number
    place: number
    date: number
    email: number
    phoneNumber: number
    website: number
    type: number
    description: number
    document: number
    _all: number
  }


  export type TrainingMinAggregateInputType = {
    id?: true
    title?: true
    place?: true
    date?: true
    email?: true
    phoneNumber?: true
    website?: true
    type?: true
    description?: true
    document?: true
  }

  export type TrainingMaxAggregateInputType = {
    id?: true
    title?: true
    place?: true
    date?: true
    email?: true
    phoneNumber?: true
    website?: true
    type?: true
    description?: true
    document?: true
  }

  export type TrainingCountAggregateInputType = {
    id?: true
    title?: true
    place?: true
    date?: true
    email?: true
    phoneNumber?: true
    website?: true
    type?: true
    description?: true
    document?: true
    _all?: true
  }

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

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




  export type TrainingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TrainingWhereInput
    orderBy?: TrainingOrderByWithAggregationInput | TrainingOrderByWithAggregationInput[]
    by: TrainingScalarFieldEnum[] | TrainingScalarFieldEnum
    having?: TrainingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TrainingCountAggregateInputType | true
    _min?: TrainingMinAggregateInputType
    _max?: TrainingMaxAggregateInputType
  }

  export type TrainingGroupByOutputType = {
    id: string
    title: string
    place: string
    date: Date
    email: string
    phoneNumber: string
    website: string
    type: $Enums.TrainingType
    description: string
    document: string | null
    _count: TrainingCountAggregateOutputType | null
    _min: TrainingMinAggregateOutputType | null
    _max: TrainingMaxAggregateOutputType | null
  }

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


  export type TrainingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    place?: boolean
    date?: boolean
    email?: boolean
    phoneNumber?: boolean
    website?: boolean
    type?: boolean
    description?: boolean
    document?: boolean
  }, ExtArgs["result"]["training"]>

  export type TrainingSelectScalar = {
    id?: boolean
    title?: boolean
    place?: boolean
    date?: boolean
    email?: boolean
    phoneNumber?: boolean
    website?: boolean
    type?: boolean
    description?: boolean
    document?: boolean
  }



  export type $TrainingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Training"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      place: string
      date: Date
      email: string
      phoneNumber: string
      website: string
      type: $Enums.TrainingType
      description: string
      document: string | null
    }, ExtArgs["result"]["training"]>
    composites: {}
  }


  type TrainingGetPayload<S extends boolean | null | undefined | TrainingDefaultArgs> = $Result.GetResult<Prisma.$TrainingPayload, S>

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

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

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

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

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

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

    /**
     * Create a Training.
     * @param {TrainingCreateArgs} args - Arguments to create a Training.
     * @example
     * // Create one Training
     * const Training = await prisma.training.create({
     *   data: {
     *     // ... data to create a Training
     *   }
     * })
     * 
    **/
    create<T extends TrainingCreateArgs<ExtArgs>>(
      args: SelectSubset<T, TrainingCreateArgs<ExtArgs>>
    ): Prisma__TrainingClient<$Result.GetResult<Prisma.$TrainingPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Training.
     * @param {TrainingDeleteArgs} args - Arguments to delete one Training.
     * @example
     * // Delete one Training
     * const Training = await prisma.training.delete({
     *   where: {
     *     // ... filter to delete one Training
     *   }
     * })
     * 
    **/
    delete<T extends TrainingDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, TrainingDeleteArgs<ExtArgs>>
    ): Prisma__TrainingClient<$Result.GetResult<Prisma.$TrainingPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Training.
     * @param {TrainingUpdateArgs} args - Arguments to update one Training.
     * @example
     * // Update one Training
     * const training = await prisma.training.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends TrainingUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, TrainingUpdateArgs<ExtArgs>>
    ): Prisma__TrainingClient<$Result.GetResult<Prisma.$TrainingPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Training.
   * 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__TrainingClient<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 Training model
   */ 
  interface TrainingFieldRefs {
    readonly id: FieldRef<"Training", 'String'>
    readonly title: FieldRef<"Training", 'String'>
    readonly place: FieldRef<"Training", 'String'>
    readonly date: FieldRef<"Training", 'DateTime'>
    readonly email: FieldRef<"Training", 'String'>
    readonly phoneNumber: FieldRef<"Training", 'String'>
    readonly website: FieldRef<"Training", 'String'>
    readonly type: FieldRef<"Training", 'TrainingType'>
    readonly description: FieldRef<"Training", 'String'>
    readonly document: FieldRef<"Training", 'String'>
  }
    

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

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

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

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

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

  /**
   * Training create
   */
  export type TrainingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Training
     */
    select?: TrainingSelect<ExtArgs> | null
    /**
     * The data needed to create a Training.
     */
    data: XOR<TrainingCreateInput, TrainingUncheckedCreateInput>
  }

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

  /**
   * Training update
   */
  export type TrainingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Training
     */
    select?: TrainingSelect<ExtArgs> | null
    /**
     * The data needed to update a Training.
     */
    data: XOR<TrainingUpdateInput, TrainingUncheckedUpdateInput>
    /**
     * Choose, which Training to update.
     */
    where: TrainingWhereUniqueInput
  }

  /**
   * Training updateMany
   */
  export type TrainingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Trainings.
     */
    data: XOR<TrainingUpdateManyMutationInput, TrainingUncheckedUpdateManyInput>
    /**
     * Filter which Trainings to update
     */
    where?: TrainingWhereInput
  }

  /**
   * Training upsert
   */
  export type TrainingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Training
     */
    select?: TrainingSelect<ExtArgs> | null
    /**
     * The filter to search for the Training to update in case it exists.
     */
    where: TrainingWhereUniqueInput
    /**
     * In case the Training found by the `where` argument doesn't exist, create a new Training with this data.
     */
    create: XOR<TrainingCreateInput, TrainingUncheckedCreateInput>
    /**
     * In case the Training was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TrainingUpdateInput, TrainingUncheckedUpdateInput>
  }

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

  /**
   * Training deleteMany
   */
  export type TrainingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Trainings to delete
     */
    where?: TrainingWhereInput
  }

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


  /**
   * Model Fair
   */

  export type AggregateFair = {
    _count: FairCountAggregateOutputType | null
    _min: FairMinAggregateOutputType | null
    _max: FairMaxAggregateOutputType | null
  }

  export type FairMinAggregateOutputType = {
    id: string | null
    title: string | null
    country: string | null
    place: string | null
    startDate: Date | null
    endDate: Date | null
    sector: string | null
    organizer: string | null
    phoneNumber: string | null
    fax: string | null
    email: string | null
    website: string | null
  }

  export type FairMaxAggregateOutputType = {
    id: string | null
    title: string | null
    country: string | null
    place: string | null
    startDate: Date | null
    endDate: Date | null
    sector: string | null
    organizer: string | null
    phoneNumber: string | null
    fax: string | null
    email: string | null
    website: string | null
  }

  export type FairCountAggregateOutputType = {
    id: number
    title: number
    country: number
    place: number
    startDate: number
    endDate: number
    sector: number
    organizer: number
    phoneNumber: number
    fax: number
    email: number
    website: number
    _all: number
  }


  export type FairMinAggregateInputType = {
    id?: true
    title?: true
    country?: true
    place?: true
    startDate?: true
    endDate?: true
    sector?: true
    organizer?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
  }

  export type FairMaxAggregateInputType = {
    id?: true
    title?: true
    country?: true
    place?: true
    startDate?: true
    endDate?: true
    sector?: true
    organizer?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
  }

  export type FairCountAggregateInputType = {
    id?: true
    title?: true
    country?: true
    place?: true
    startDate?: true
    endDate?: true
    sector?: true
    organizer?: true
    phoneNumber?: true
    fax?: true
    email?: true
    website?: true
    _all?: true
  }

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

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




  export type FairGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FairWhereInput
    orderBy?: FairOrderByWithAggregationInput | FairOrderByWithAggregationInput[]
    by: FairScalarFieldEnum[] | FairScalarFieldEnum
    having?: FairScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FairCountAggregateInputType | true
    _min?: FairMinAggregateInputType
    _max?: FairMaxAggregateInputType
  }

  export type FairGroupByOutputType = {
    id: string
    title: string
    country: string
    place: string
    startDate: Date
    endDate: Date
    sector: string
    organizer: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    _count: FairCountAggregateOutputType | null
    _min: FairMinAggregateOutputType | null
    _max: FairMaxAggregateOutputType | null
  }

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


  export type FairSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    country?: boolean
    place?: boolean
    startDate?: boolean
    endDate?: boolean
    sector?: boolean
    organizer?: boolean
    phoneNumber?: boolean
    fax?: boolean
    email?: boolean
    website?: boolean
  }, ExtArgs["result"]["fair"]>

  export type FairSelectScalar = {
    id?: boolean
    title?: boolean
    country?: boolean
    place?: boolean
    startDate?: boolean
    endDate?: boolean
    sector?: boolean
    organizer?: boolean
    phoneNumber?: boolean
    fax?: boolean
    email?: boolean
    website?: boolean
  }



  export type $FairPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Fair"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      country: string
      place: string
      startDate: Date
      endDate: Date
      sector: string
      organizer: string
      phoneNumber: string
      fax: string
      email: string
      website: string
    }, ExtArgs["result"]["fair"]>
    composites: {}
  }


  type FairGetPayload<S extends boolean | null | undefined | FairDefaultArgs> = $Result.GetResult<Prisma.$FairPayload, S>

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

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

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

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

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

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

    /**
     * Create a Fair.
     * @param {FairCreateArgs} args - Arguments to create a Fair.
     * @example
     * // Create one Fair
     * const Fair = await prisma.fair.create({
     *   data: {
     *     // ... data to create a Fair
     *   }
     * })
     * 
    **/
    create<T extends FairCreateArgs<ExtArgs>>(
      args: SelectSubset<T, FairCreateArgs<ExtArgs>>
    ): Prisma__FairClient<$Result.GetResult<Prisma.$FairPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Fair.
     * @param {FairDeleteArgs} args - Arguments to delete one Fair.
     * @example
     * // Delete one Fair
     * const Fair = await prisma.fair.delete({
     *   where: {
     *     // ... filter to delete one Fair
     *   }
     * })
     * 
    **/
    delete<T extends FairDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, FairDeleteArgs<ExtArgs>>
    ): Prisma__FairClient<$Result.GetResult<Prisma.$FairPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Fair.
     * @param {FairUpdateArgs} args - Arguments to update one Fair.
     * @example
     * // Update one Fair
     * const fair = await prisma.fair.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends FairUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, FairUpdateArgs<ExtArgs>>
    ): Prisma__FairClient<$Result.GetResult<Prisma.$FairPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Fair.
   * 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__FairClient<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 Fair model
   */ 
  interface FairFieldRefs {
    readonly id: FieldRef<"Fair", 'String'>
    readonly title: FieldRef<"Fair", 'String'>
    readonly country: FieldRef<"Fair", 'String'>
    readonly place: FieldRef<"Fair", 'String'>
    readonly startDate: FieldRef<"Fair", 'DateTime'>
    readonly endDate: FieldRef<"Fair", 'DateTime'>
    readonly sector: FieldRef<"Fair", 'String'>
    readonly organizer: FieldRef<"Fair", 'String'>
    readonly phoneNumber: FieldRef<"Fair", 'String'>
    readonly fax: FieldRef<"Fair", 'String'>
    readonly email: FieldRef<"Fair", 'String'>
    readonly website: FieldRef<"Fair", 'String'>
  }
    

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

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

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

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

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

  /**
   * Fair create
   */
  export type FairCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Fair
     */
    select?: FairSelect<ExtArgs> | null
    /**
     * The data needed to create a Fair.
     */
    data: XOR<FairCreateInput, FairUncheckedCreateInput>
  }

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

  /**
   * Fair update
   */
  export type FairUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Fair
     */
    select?: FairSelect<ExtArgs> | null
    /**
     * The data needed to update a Fair.
     */
    data: XOR<FairUpdateInput, FairUncheckedUpdateInput>
    /**
     * Choose, which Fair to update.
     */
    where: FairWhereUniqueInput
  }

  /**
   * Fair updateMany
   */
  export type FairUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Fairs.
     */
    data: XOR<FairUpdateManyMutationInput, FairUncheckedUpdateManyInput>
    /**
     * Filter which Fairs to update
     */
    where?: FairWhereInput
  }

  /**
   * Fair upsert
   */
  export type FairUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Fair
     */
    select?: FairSelect<ExtArgs> | null
    /**
     * The filter to search for the Fair to update in case it exists.
     */
    where: FairWhereUniqueInput
    /**
     * In case the Fair found by the `where` argument doesn't exist, create a new Fair with this data.
     */
    create: XOR<FairCreateInput, FairUncheckedCreateInput>
    /**
     * In case the Fair was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FairUpdateInput, FairUncheckedUpdateInput>
  }

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

  /**
   * Fair deleteMany
   */
  export type FairDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Fairs to delete
     */
    where?: FairWhereInput
  }

  /**
   * Fair without action
   */
  export type FairDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Fair
     */
    select?: FairSelect<ExtArgs> | null
  }


  /**
   * Model BusinessPlan
   */

  export type AggregateBusinessPlan = {
    _count: BusinessPlanCountAggregateOutputType | null
    _min: BusinessPlanMinAggregateOutputType | null
    _max: BusinessPlanMaxAggregateOutputType | null
  }

  export type BusinessPlanMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    nationality: string | null
    phoneNumber: string | null
    email: string | null
    projectIdea: string | null
    location: string | null
    educationAndExperience: string | null
    financingPlan: string | null
    createdAt: Date | null
  }

  export type BusinessPlanMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    nationality: string | null
    phoneNumber: string | null
    email: string | null
    projectIdea: string | null
    location: string | null
    educationAndExperience: string | null
    financingPlan: string | null
    createdAt: Date | null
  }

  export type BusinessPlanCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    nationality: number
    phoneNumber: number
    email: number
    projectIdea: number
    location: number
    educationAndExperience: number
    financingPlan: number
    createdAt: number
    _all: number
  }


  export type BusinessPlanMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    nationality?: true
    phoneNumber?: true
    email?: true
    projectIdea?: true
    location?: true
    educationAndExperience?: true
    financingPlan?: true
    createdAt?: true
  }

  export type BusinessPlanMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    nationality?: true
    phoneNumber?: true
    email?: true
    projectIdea?: true
    location?: true
    educationAndExperience?: true
    financingPlan?: true
    createdAt?: true
  }

  export type BusinessPlanCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    nationality?: true
    phoneNumber?: true
    email?: true
    projectIdea?: true
    location?: true
    educationAndExperience?: true
    financingPlan?: true
    createdAt?: true
    _all?: true
  }

  export type BusinessPlanAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BusinessPlan to aggregate.
     */
    where?: BusinessPlanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BusinessPlans to fetch.
     */
    orderBy?: BusinessPlanOrderByWithRelationInput | BusinessPlanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BusinessPlanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BusinessPlans from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BusinessPlans.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned BusinessPlans
    **/
    _count?: true | BusinessPlanCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BusinessPlanMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BusinessPlanMaxAggregateInputType
  }

  export type GetBusinessPlanAggregateType<T extends BusinessPlanAggregateArgs> = {
        [P in keyof T & keyof AggregateBusinessPlan]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateBusinessPlan[P]>
      : GetScalarType<T[P], AggregateBusinessPlan[P]>
  }




  export type BusinessPlanGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BusinessPlanWhereInput
    orderBy?: BusinessPlanOrderByWithAggregationInput | BusinessPlanOrderByWithAggregationInput[]
    by: BusinessPlanScalarFieldEnum[] | BusinessPlanScalarFieldEnum
    having?: BusinessPlanScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BusinessPlanCountAggregateInputType | true
    _min?: BusinessPlanMinAggregateInputType
    _max?: BusinessPlanMaxAggregateInputType
  }

  export type BusinessPlanGroupByOutputType = {
    id: string
    firstName: string
    lastName: string
    nationality: string
    phoneNumber: string
    email: string
    projectIdea: string
    location: string
    educationAndExperience: string
    financingPlan: string
    createdAt: Date
    _count: BusinessPlanCountAggregateOutputType | null
    _min: BusinessPlanMinAggregateOutputType | null
    _max: BusinessPlanMaxAggregateOutputType | null
  }

  type GetBusinessPlanGroupByPayload<T extends BusinessPlanGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<BusinessPlanGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof BusinessPlanGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], BusinessPlanGroupByOutputType[P]>
            : GetScalarType<T[P], BusinessPlanGroupByOutputType[P]>
        }
      >
    >


  export type BusinessPlanSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    nationality?: boolean
    phoneNumber?: boolean
    email?: boolean
    projectIdea?: boolean
    location?: boolean
    educationAndExperience?: boolean
    financingPlan?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["businessPlan"]>

  export type BusinessPlanSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    nationality?: boolean
    phoneNumber?: boolean
    email?: boolean
    projectIdea?: boolean
    location?: boolean
    educationAndExperience?: boolean
    financingPlan?: boolean
    createdAt?: boolean
  }



  export type $BusinessPlanPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "BusinessPlan"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string
      lastName: string
      nationality: string
      phoneNumber: string
      email: string
      projectIdea: string
      location: string
      educationAndExperience: string
      financingPlan: string
      createdAt: Date
    }, ExtArgs["result"]["businessPlan"]>
    composites: {}
  }


  type BusinessPlanGetPayload<S extends boolean | null | undefined | BusinessPlanDefaultArgs> = $Result.GetResult<Prisma.$BusinessPlanPayload, S>

  type BusinessPlanCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BusinessPlanFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: BusinessPlanCountAggregateInputType | true
    }

  export interface BusinessPlanDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['BusinessPlan'], meta: { name: 'BusinessPlan' } }
    /**
     * Find zero or one BusinessPlan that matches the filter.
     * @param {BusinessPlanFindUniqueArgs} args - Arguments to find a BusinessPlan
     * @example
     * // Get one BusinessPlan
     * const businessPlan = await prisma.businessPlan.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends BusinessPlanFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanFindUniqueArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one BusinessPlan that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {BusinessPlanFindUniqueOrThrowArgs} args - Arguments to find a BusinessPlan
     * @example
     * // Get one BusinessPlan
     * const businessPlan = await prisma.businessPlan.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends BusinessPlanFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first BusinessPlan 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 {BusinessPlanFindFirstArgs} args - Arguments to find a BusinessPlan
     * @example
     * // Get one BusinessPlan
     * const businessPlan = await prisma.businessPlan.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends BusinessPlanFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanFindFirstArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first BusinessPlan 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 {BusinessPlanFindFirstOrThrowArgs} args - Arguments to find a BusinessPlan
     * @example
     * // Get one BusinessPlan
     * const businessPlan = await prisma.businessPlan.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends BusinessPlanFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more BusinessPlans 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 {BusinessPlanFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all BusinessPlans
     * const businessPlans = await prisma.businessPlan.findMany()
     * 
     * // Get first 10 BusinessPlans
     * const businessPlans = await prisma.businessPlan.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const businessPlanWithIdOnly = await prisma.businessPlan.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends BusinessPlanFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a BusinessPlan.
     * @param {BusinessPlanCreateArgs} args - Arguments to create a BusinessPlan.
     * @example
     * // Create one BusinessPlan
     * const BusinessPlan = await prisma.businessPlan.create({
     *   data: {
     *     // ... data to create a BusinessPlan
     *   }
     * })
     * 
    **/
    create<T extends BusinessPlanCreateArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanCreateArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many BusinessPlans.
     *     @param {BusinessPlanCreateManyArgs} args - Arguments to create many BusinessPlans.
     *     @example
     *     // Create many BusinessPlans
     *     const businessPlan = await prisma.businessPlan.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends BusinessPlanCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a BusinessPlan.
     * @param {BusinessPlanDeleteArgs} args - Arguments to delete one BusinessPlan.
     * @example
     * // Delete one BusinessPlan
     * const BusinessPlan = await prisma.businessPlan.delete({
     *   where: {
     *     // ... filter to delete one BusinessPlan
     *   }
     * })
     * 
    **/
    delete<T extends BusinessPlanDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanDeleteArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one BusinessPlan.
     * @param {BusinessPlanUpdateArgs} args - Arguments to update one BusinessPlan.
     * @example
     * // Update one BusinessPlan
     * const businessPlan = await prisma.businessPlan.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends BusinessPlanUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanUpdateArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more BusinessPlans.
     * @param {BusinessPlanDeleteManyArgs} args - Arguments to filter BusinessPlans to delete.
     * @example
     * // Delete a few BusinessPlans
     * const { count } = await prisma.businessPlan.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends BusinessPlanDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BusinessPlanDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more BusinessPlans.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BusinessPlanUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many BusinessPlans
     * const businessPlan = await prisma.businessPlan.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends BusinessPlanUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one BusinessPlan.
     * @param {BusinessPlanUpsertArgs} args - Arguments to update or create a BusinessPlan.
     * @example
     * // Update or create a BusinessPlan
     * const businessPlan = await prisma.businessPlan.upsert({
     *   create: {
     *     // ... data to create a BusinessPlan
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the BusinessPlan we want to update
     *   }
     * })
    **/
    upsert<T extends BusinessPlanUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, BusinessPlanUpsertArgs<ExtArgs>>
    ): Prisma__BusinessPlanClient<$Result.GetResult<Prisma.$BusinessPlanPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of BusinessPlans.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BusinessPlanCountArgs} args - Arguments to filter BusinessPlans to count.
     * @example
     * // Count the number of BusinessPlans
     * const count = await prisma.businessPlan.count({
     *   where: {
     *     // ... the filter for the BusinessPlans we want to count
     *   }
     * })
    **/
    count<T extends BusinessPlanCountArgs>(
      args?: Subset<T, BusinessPlanCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], BusinessPlanCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a BusinessPlan.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BusinessPlanAggregateArgs} 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 BusinessPlanAggregateArgs>(args: Subset<T, BusinessPlanAggregateArgs>): Prisma.PrismaPromise<GetBusinessPlanAggregateType<T>>

    /**
     * Group by BusinessPlan.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BusinessPlanGroupByArgs} 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 BusinessPlanGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: BusinessPlanGroupByArgs['orderBy'] }
        : { orderBy?: BusinessPlanGroupByArgs['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, BusinessPlanGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetBusinessPlanGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the BusinessPlan model
   */
  readonly fields: BusinessPlanFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for BusinessPlan.
   * 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__BusinessPlanClient<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 BusinessPlan model
   */ 
  interface BusinessPlanFieldRefs {
    readonly id: FieldRef<"BusinessPlan", 'String'>
    readonly firstName: FieldRef<"BusinessPlan", 'String'>
    readonly lastName: FieldRef<"BusinessPlan", 'String'>
    readonly nationality: FieldRef<"BusinessPlan", 'String'>
    readonly phoneNumber: FieldRef<"BusinessPlan", 'String'>
    readonly email: FieldRef<"BusinessPlan", 'String'>
    readonly projectIdea: FieldRef<"BusinessPlan", 'String'>
    readonly location: FieldRef<"BusinessPlan", 'String'>
    readonly educationAndExperience: FieldRef<"BusinessPlan", 'String'>
    readonly financingPlan: FieldRef<"BusinessPlan", 'String'>
    readonly createdAt: FieldRef<"BusinessPlan", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * BusinessPlan findUnique
   */
  export type BusinessPlanFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter, which BusinessPlan to fetch.
     */
    where: BusinessPlanWhereUniqueInput
  }

  /**
   * BusinessPlan findUniqueOrThrow
   */
  export type BusinessPlanFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter, which BusinessPlan to fetch.
     */
    where: BusinessPlanWhereUniqueInput
  }

  /**
   * BusinessPlan findFirst
   */
  export type BusinessPlanFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter, which BusinessPlan to fetch.
     */
    where?: BusinessPlanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BusinessPlans to fetch.
     */
    orderBy?: BusinessPlanOrderByWithRelationInput | BusinessPlanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BusinessPlans.
     */
    cursor?: BusinessPlanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BusinessPlans from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BusinessPlans.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BusinessPlans.
     */
    distinct?: BusinessPlanScalarFieldEnum | BusinessPlanScalarFieldEnum[]
  }

  /**
   * BusinessPlan findFirstOrThrow
   */
  export type BusinessPlanFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter, which BusinessPlan to fetch.
     */
    where?: BusinessPlanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BusinessPlans to fetch.
     */
    orderBy?: BusinessPlanOrderByWithRelationInput | BusinessPlanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BusinessPlans.
     */
    cursor?: BusinessPlanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BusinessPlans from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BusinessPlans.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BusinessPlans.
     */
    distinct?: BusinessPlanScalarFieldEnum | BusinessPlanScalarFieldEnum[]
  }

  /**
   * BusinessPlan findMany
   */
  export type BusinessPlanFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter, which BusinessPlans to fetch.
     */
    where?: BusinessPlanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BusinessPlans to fetch.
     */
    orderBy?: BusinessPlanOrderByWithRelationInput | BusinessPlanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing BusinessPlans.
     */
    cursor?: BusinessPlanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BusinessPlans from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BusinessPlans.
     */
    skip?: number
    distinct?: BusinessPlanScalarFieldEnum | BusinessPlanScalarFieldEnum[]
  }

  /**
   * BusinessPlan create
   */
  export type BusinessPlanCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * The data needed to create a BusinessPlan.
     */
    data: XOR<BusinessPlanCreateInput, BusinessPlanUncheckedCreateInput>
  }

  /**
   * BusinessPlan createMany
   */
  export type BusinessPlanCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many BusinessPlans.
     */
    data: BusinessPlanCreateManyInput | BusinessPlanCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * BusinessPlan update
   */
  export type BusinessPlanUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * The data needed to update a BusinessPlan.
     */
    data: XOR<BusinessPlanUpdateInput, BusinessPlanUncheckedUpdateInput>
    /**
     * Choose, which BusinessPlan to update.
     */
    where: BusinessPlanWhereUniqueInput
  }

  /**
   * BusinessPlan updateMany
   */
  export type BusinessPlanUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update BusinessPlans.
     */
    data: XOR<BusinessPlanUpdateManyMutationInput, BusinessPlanUncheckedUpdateManyInput>
    /**
     * Filter which BusinessPlans to update
     */
    where?: BusinessPlanWhereInput
  }

  /**
   * BusinessPlan upsert
   */
  export type BusinessPlanUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * The filter to search for the BusinessPlan to update in case it exists.
     */
    where: BusinessPlanWhereUniqueInput
    /**
     * In case the BusinessPlan found by the `where` argument doesn't exist, create a new BusinessPlan with this data.
     */
    create: XOR<BusinessPlanCreateInput, BusinessPlanUncheckedCreateInput>
    /**
     * In case the BusinessPlan was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BusinessPlanUpdateInput, BusinessPlanUncheckedUpdateInput>
  }

  /**
   * BusinessPlan delete
   */
  export type BusinessPlanDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
    /**
     * Filter which BusinessPlan to delete.
     */
    where: BusinessPlanWhereUniqueInput
  }

  /**
   * BusinessPlan deleteMany
   */
  export type BusinessPlanDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BusinessPlans to delete
     */
    where?: BusinessPlanWhereInput
  }

  /**
   * BusinessPlan without action
   */
  export type BusinessPlanDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BusinessPlan
     */
    select?: BusinessPlanSelect<ExtArgs> | null
  }


  /**
   * Model MarketResearch
   */

  export type AggregateMarketResearch = {
    _count: MarketResearchCountAggregateOutputType | null
    _min: MarketResearchMinAggregateOutputType | null
    _max: MarketResearchMaxAggregateOutputType | null
  }

  export type MarketResearchMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    address: string | null
    city: string | null
    state: string | null
    zipCode: string | null
    country: string | null
    projectIdea: string | null
    educationAndExperience: string | null
    createdAt: Date | null
  }

  export type MarketResearchMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    address: string | null
    city: string | null
    state: string | null
    zipCode: string | null
    country: string | null
    projectIdea: string | null
    educationAndExperience: string | null
    createdAt: Date | null
  }

  export type MarketResearchCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    phoneNumber: number
    email: number
    address: number
    city: number
    state: number
    zipCode: number
    country: number
    projectIdea: number
    educationAndExperience: number
    createdAt: number
    _all: number
  }


  export type MarketResearchMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    address?: true
    city?: true
    state?: true
    zipCode?: true
    country?: true
    projectIdea?: true
    educationAndExperience?: true
    createdAt?: true
  }

  export type MarketResearchMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    address?: true
    city?: true
    state?: true
    zipCode?: true
    country?: true
    projectIdea?: true
    educationAndExperience?: true
    createdAt?: true
  }

  export type MarketResearchCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    address?: true
    city?: true
    state?: true
    zipCode?: true
    country?: true
    projectIdea?: true
    educationAndExperience?: true
    createdAt?: true
    _all?: true
  }

  export type MarketResearchAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MarketResearch to aggregate.
     */
    where?: MarketResearchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketResearches to fetch.
     */
    orderBy?: MarketResearchOrderByWithRelationInput | MarketResearchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MarketResearchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketResearches from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MarketResearches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MarketResearches
    **/
    _count?: true | MarketResearchCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MarketResearchMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MarketResearchMaxAggregateInputType
  }

  export type GetMarketResearchAggregateType<T extends MarketResearchAggregateArgs> = {
        [P in keyof T & keyof AggregateMarketResearch]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMarketResearch[P]>
      : GetScalarType<T[P], AggregateMarketResearch[P]>
  }




  export type MarketResearchGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MarketResearchWhereInput
    orderBy?: MarketResearchOrderByWithAggregationInput | MarketResearchOrderByWithAggregationInput[]
    by: MarketResearchScalarFieldEnum[] | MarketResearchScalarFieldEnum
    having?: MarketResearchScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MarketResearchCountAggregateInputType | true
    _min?: MarketResearchMinAggregateInputType
    _max?: MarketResearchMaxAggregateInputType
  }

  export type MarketResearchGroupByOutputType = {
    id: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    address: string
    city: string
    state: string
    zipCode: string
    country: string
    projectIdea: string
    educationAndExperience: string
    createdAt: Date
    _count: MarketResearchCountAggregateOutputType | null
    _min: MarketResearchMinAggregateOutputType | null
    _max: MarketResearchMaxAggregateOutputType | null
  }

  type GetMarketResearchGroupByPayload<T extends MarketResearchGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MarketResearchGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MarketResearchGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MarketResearchGroupByOutputType[P]>
            : GetScalarType<T[P], MarketResearchGroupByOutputType[P]>
        }
      >
    >


  export type MarketResearchSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
    country?: boolean
    projectIdea?: boolean
    educationAndExperience?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["marketResearch"]>

  export type MarketResearchSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    address?: boolean
    city?: boolean
    state?: boolean
    zipCode?: boolean
    country?: boolean
    projectIdea?: boolean
    educationAndExperience?: boolean
    createdAt?: boolean
  }



  export type $MarketResearchPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MarketResearch"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string
      lastName: string
      phoneNumber: string
      email: string
      address: string
      city: string
      state: string
      zipCode: string
      country: string
      projectIdea: string
      educationAndExperience: string
      createdAt: Date
    }, ExtArgs["result"]["marketResearch"]>
    composites: {}
  }


  type MarketResearchGetPayload<S extends boolean | null | undefined | MarketResearchDefaultArgs> = $Result.GetResult<Prisma.$MarketResearchPayload, S>

  type MarketResearchCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MarketResearchFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: MarketResearchCountAggregateInputType | true
    }

  export interface MarketResearchDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MarketResearch'], meta: { name: 'MarketResearch' } }
    /**
     * Find zero or one MarketResearch that matches the filter.
     * @param {MarketResearchFindUniqueArgs} args - Arguments to find a MarketResearch
     * @example
     * // Get one MarketResearch
     * const marketResearch = await prisma.marketResearch.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends MarketResearchFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchFindUniqueArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one MarketResearch that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {MarketResearchFindUniqueOrThrowArgs} args - Arguments to find a MarketResearch
     * @example
     * // Get one MarketResearch
     * const marketResearch = await prisma.marketResearch.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends MarketResearchFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first MarketResearch 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 {MarketResearchFindFirstArgs} args - Arguments to find a MarketResearch
     * @example
     * // Get one MarketResearch
     * const marketResearch = await prisma.marketResearch.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends MarketResearchFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchFindFirstArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first MarketResearch 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 {MarketResearchFindFirstOrThrowArgs} args - Arguments to find a MarketResearch
     * @example
     * // Get one MarketResearch
     * const marketResearch = await prisma.marketResearch.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends MarketResearchFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more MarketResearches 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 {MarketResearchFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MarketResearches
     * const marketResearches = await prisma.marketResearch.findMany()
     * 
     * // Get first 10 MarketResearches
     * const marketResearches = await prisma.marketResearch.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const marketResearchWithIdOnly = await prisma.marketResearch.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends MarketResearchFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a MarketResearch.
     * @param {MarketResearchCreateArgs} args - Arguments to create a MarketResearch.
     * @example
     * // Create one MarketResearch
     * const MarketResearch = await prisma.marketResearch.create({
     *   data: {
     *     // ... data to create a MarketResearch
     *   }
     * })
     * 
    **/
    create<T extends MarketResearchCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchCreateArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many MarketResearches.
     *     @param {MarketResearchCreateManyArgs} args - Arguments to create many MarketResearches.
     *     @example
     *     // Create many MarketResearches
     *     const marketResearch = await prisma.marketResearch.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends MarketResearchCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a MarketResearch.
     * @param {MarketResearchDeleteArgs} args - Arguments to delete one MarketResearch.
     * @example
     * // Delete one MarketResearch
     * const MarketResearch = await prisma.marketResearch.delete({
     *   where: {
     *     // ... filter to delete one MarketResearch
     *   }
     * })
     * 
    **/
    delete<T extends MarketResearchDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchDeleteArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one MarketResearch.
     * @param {MarketResearchUpdateArgs} args - Arguments to update one MarketResearch.
     * @example
     * // Update one MarketResearch
     * const marketResearch = await prisma.marketResearch.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MarketResearchUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchUpdateArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more MarketResearches.
     * @param {MarketResearchDeleteManyArgs} args - Arguments to filter MarketResearches to delete.
     * @example
     * // Delete a few MarketResearches
     * const { count } = await prisma.marketResearch.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends MarketResearchDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MarketResearchDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MarketResearches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketResearchUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MarketResearches
     * const marketResearch = await prisma.marketResearch.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends MarketResearchUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one MarketResearch.
     * @param {MarketResearchUpsertArgs} args - Arguments to update or create a MarketResearch.
     * @example
     * // Update or create a MarketResearch
     * const marketResearch = await prisma.marketResearch.upsert({
     *   create: {
     *     // ... data to create a MarketResearch
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MarketResearch we want to update
     *   }
     * })
    **/
    upsert<T extends MarketResearchUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, MarketResearchUpsertArgs<ExtArgs>>
    ): Prisma__MarketResearchClient<$Result.GetResult<Prisma.$MarketResearchPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of MarketResearches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketResearchCountArgs} args - Arguments to filter MarketResearches to count.
     * @example
     * // Count the number of MarketResearches
     * const count = await prisma.marketResearch.count({
     *   where: {
     *     // ... the filter for the MarketResearches we want to count
     *   }
     * })
    **/
    count<T extends MarketResearchCountArgs>(
      args?: Subset<T, MarketResearchCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MarketResearchCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MarketResearch.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketResearchAggregateArgs} 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 MarketResearchAggregateArgs>(args: Subset<T, MarketResearchAggregateArgs>): Prisma.PrismaPromise<GetMarketResearchAggregateType<T>>

    /**
     * Group by MarketResearch.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketResearchGroupByArgs} 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 MarketResearchGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MarketResearchGroupByArgs['orderBy'] }
        : { orderBy?: MarketResearchGroupByArgs['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, MarketResearchGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMarketResearchGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MarketResearch model
   */
  readonly fields: MarketResearchFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MarketResearch.
   * 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__MarketResearchClient<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 MarketResearch model
   */ 
  interface MarketResearchFieldRefs {
    readonly id: FieldRef<"MarketResearch", 'String'>
    readonly firstName: FieldRef<"MarketResearch", 'String'>
    readonly lastName: FieldRef<"MarketResearch", 'String'>
    readonly phoneNumber: FieldRef<"MarketResearch", 'String'>
    readonly email: FieldRef<"MarketResearch", 'String'>
    readonly address: FieldRef<"MarketResearch", 'String'>
    readonly city: FieldRef<"MarketResearch", 'String'>
    readonly state: FieldRef<"MarketResearch", 'String'>
    readonly zipCode: FieldRef<"MarketResearch", 'String'>
    readonly country: FieldRef<"MarketResearch", 'String'>
    readonly projectIdea: FieldRef<"MarketResearch", 'String'>
    readonly educationAndExperience: FieldRef<"MarketResearch", 'String'>
    readonly createdAt: FieldRef<"MarketResearch", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * MarketResearch findUnique
   */
  export type MarketResearchFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter, which MarketResearch to fetch.
     */
    where: MarketResearchWhereUniqueInput
  }

  /**
   * MarketResearch findUniqueOrThrow
   */
  export type MarketResearchFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter, which MarketResearch to fetch.
     */
    where: MarketResearchWhereUniqueInput
  }

  /**
   * MarketResearch findFirst
   */
  export type MarketResearchFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter, which MarketResearch to fetch.
     */
    where?: MarketResearchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketResearches to fetch.
     */
    orderBy?: MarketResearchOrderByWithRelationInput | MarketResearchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MarketResearches.
     */
    cursor?: MarketResearchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketResearches from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MarketResearches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MarketResearches.
     */
    distinct?: MarketResearchScalarFieldEnum | MarketResearchScalarFieldEnum[]
  }

  /**
   * MarketResearch findFirstOrThrow
   */
  export type MarketResearchFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter, which MarketResearch to fetch.
     */
    where?: MarketResearchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketResearches to fetch.
     */
    orderBy?: MarketResearchOrderByWithRelationInput | MarketResearchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MarketResearches.
     */
    cursor?: MarketResearchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketResearches from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MarketResearches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MarketResearches.
     */
    distinct?: MarketResearchScalarFieldEnum | MarketResearchScalarFieldEnum[]
  }

  /**
   * MarketResearch findMany
   */
  export type MarketResearchFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter, which MarketResearches to fetch.
     */
    where?: MarketResearchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketResearches to fetch.
     */
    orderBy?: MarketResearchOrderByWithRelationInput | MarketResearchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MarketResearches.
     */
    cursor?: MarketResearchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketResearches from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MarketResearches.
     */
    skip?: number
    distinct?: MarketResearchScalarFieldEnum | MarketResearchScalarFieldEnum[]
  }

  /**
   * MarketResearch create
   */
  export type MarketResearchCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * The data needed to create a MarketResearch.
     */
    data: XOR<MarketResearchCreateInput, MarketResearchUncheckedCreateInput>
  }

  /**
   * MarketResearch createMany
   */
  export type MarketResearchCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MarketResearches.
     */
    data: MarketResearchCreateManyInput | MarketResearchCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MarketResearch update
   */
  export type MarketResearchUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * The data needed to update a MarketResearch.
     */
    data: XOR<MarketResearchUpdateInput, MarketResearchUncheckedUpdateInput>
    /**
     * Choose, which MarketResearch to update.
     */
    where: MarketResearchWhereUniqueInput
  }

  /**
   * MarketResearch updateMany
   */
  export type MarketResearchUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MarketResearches.
     */
    data: XOR<MarketResearchUpdateManyMutationInput, MarketResearchUncheckedUpdateManyInput>
    /**
     * Filter which MarketResearches to update
     */
    where?: MarketResearchWhereInput
  }

  /**
   * MarketResearch upsert
   */
  export type MarketResearchUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * The filter to search for the MarketResearch to update in case it exists.
     */
    where: MarketResearchWhereUniqueInput
    /**
     * In case the MarketResearch found by the `where` argument doesn't exist, create a new MarketResearch with this data.
     */
    create: XOR<MarketResearchCreateInput, MarketResearchUncheckedCreateInput>
    /**
     * In case the MarketResearch was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MarketResearchUpdateInput, MarketResearchUncheckedUpdateInput>
  }

  /**
   * MarketResearch delete
   */
  export type MarketResearchDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
    /**
     * Filter which MarketResearch to delete.
     */
    where: MarketResearchWhereUniqueInput
  }

  /**
   * MarketResearch deleteMany
   */
  export type MarketResearchDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MarketResearches to delete
     */
    where?: MarketResearchWhereInput
  }

  /**
   * MarketResearch without action
   */
  export type MarketResearchDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketResearch
     */
    select?: MarketResearchSelect<ExtArgs> | null
  }


  /**
   * Model Networking
   */

  export type AggregateNetworking = {
    _count: NetworkingCountAggregateOutputType | null
    _min: NetworkingMinAggregateOutputType | null
    _max: NetworkingMaxAggregateOutputType | null
  }

  export type NetworkingMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    needForNetworking: string | null
    createdAt: Date | null
  }

  export type NetworkingMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    needForNetworking: string | null
    createdAt: Date | null
  }

  export type NetworkingCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    phoneNumber: number
    email: number
    activity: number
    needForNetworking: number
    createdAt: number
    _all: number
  }


  export type NetworkingMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForNetworking?: true
    createdAt?: true
  }

  export type NetworkingMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForNetworking?: true
    createdAt?: true
  }

  export type NetworkingCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForNetworking?: true
    createdAt?: true
    _all?: true
  }

  export type NetworkingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Networking to aggregate.
     */
    where?: NetworkingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Networkings to fetch.
     */
    orderBy?: NetworkingOrderByWithRelationInput | NetworkingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NetworkingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Networkings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Networkings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Networkings
    **/
    _count?: true | NetworkingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NetworkingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NetworkingMaxAggregateInputType
  }

  export type GetNetworkingAggregateType<T extends NetworkingAggregateArgs> = {
        [P in keyof T & keyof AggregateNetworking]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateNetworking[P]>
      : GetScalarType<T[P], AggregateNetworking[P]>
  }




  export type NetworkingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NetworkingWhereInput
    orderBy?: NetworkingOrderByWithAggregationInput | NetworkingOrderByWithAggregationInput[]
    by: NetworkingScalarFieldEnum[] | NetworkingScalarFieldEnum
    having?: NetworkingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NetworkingCountAggregateInputType | true
    _min?: NetworkingMinAggregateInputType
    _max?: NetworkingMaxAggregateInputType
  }

  export type NetworkingGroupByOutputType = {
    id: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForNetworking: string
    createdAt: Date
    _count: NetworkingCountAggregateOutputType | null
    _min: NetworkingMinAggregateOutputType | null
    _max: NetworkingMaxAggregateOutputType | null
  }

  type GetNetworkingGroupByPayload<T extends NetworkingGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<NetworkingGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof NetworkingGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], NetworkingGroupByOutputType[P]>
            : GetScalarType<T[P], NetworkingGroupByOutputType[P]>
        }
      >
    >


  export type NetworkingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    needForNetworking?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["networking"]>

  export type NetworkingSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    needForNetworking?: boolean
    createdAt?: boolean
  }



  export type $NetworkingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Networking"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string
      lastName: string
      phoneNumber: string
      email: string
      activity: string
      needForNetworking: string
      createdAt: Date
    }, ExtArgs["result"]["networking"]>
    composites: {}
  }


  type NetworkingGetPayload<S extends boolean | null | undefined | NetworkingDefaultArgs> = $Result.GetResult<Prisma.$NetworkingPayload, S>

  type NetworkingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<NetworkingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: NetworkingCountAggregateInputType | true
    }

  export interface NetworkingDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Networking'], meta: { name: 'Networking' } }
    /**
     * Find zero or one Networking that matches the filter.
     * @param {NetworkingFindUniqueArgs} args - Arguments to find a Networking
     * @example
     * // Get one Networking
     * const networking = await prisma.networking.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends NetworkingFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingFindUniqueArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Networking that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {NetworkingFindUniqueOrThrowArgs} args - Arguments to find a Networking
     * @example
     * // Get one Networking
     * const networking = await prisma.networking.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends NetworkingFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Networking 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 {NetworkingFindFirstArgs} args - Arguments to find a Networking
     * @example
     * // Get one Networking
     * const networking = await prisma.networking.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends NetworkingFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingFindFirstArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Networking 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 {NetworkingFindFirstOrThrowArgs} args - Arguments to find a Networking
     * @example
     * // Get one Networking
     * const networking = await prisma.networking.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends NetworkingFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Networkings 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 {NetworkingFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Networkings
     * const networkings = await prisma.networking.findMany()
     * 
     * // Get first 10 Networkings
     * const networkings = await prisma.networking.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const networkingWithIdOnly = await prisma.networking.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends NetworkingFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Networking.
     * @param {NetworkingCreateArgs} args - Arguments to create a Networking.
     * @example
     * // Create one Networking
     * const Networking = await prisma.networking.create({
     *   data: {
     *     // ... data to create a Networking
     *   }
     * })
     * 
    **/
    create<T extends NetworkingCreateArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingCreateArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Networkings.
     *     @param {NetworkingCreateManyArgs} args - Arguments to create many Networkings.
     *     @example
     *     // Create many Networkings
     *     const networking = await prisma.networking.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends NetworkingCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Networking.
     * @param {NetworkingDeleteArgs} args - Arguments to delete one Networking.
     * @example
     * // Delete one Networking
     * const Networking = await prisma.networking.delete({
     *   where: {
     *     // ... filter to delete one Networking
     *   }
     * })
     * 
    **/
    delete<T extends NetworkingDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingDeleteArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Networking.
     * @param {NetworkingUpdateArgs} args - Arguments to update one Networking.
     * @example
     * // Update one Networking
     * const networking = await prisma.networking.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends NetworkingUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingUpdateArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Networkings.
     * @param {NetworkingDeleteManyArgs} args - Arguments to filter Networkings to delete.
     * @example
     * // Delete a few Networkings
     * const { count } = await prisma.networking.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends NetworkingDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, NetworkingDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Networkings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NetworkingUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Networkings
     * const networking = await prisma.networking.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends NetworkingUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Networking.
     * @param {NetworkingUpsertArgs} args - Arguments to update or create a Networking.
     * @example
     * // Update or create a Networking
     * const networking = await prisma.networking.upsert({
     *   create: {
     *     // ... data to create a Networking
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Networking we want to update
     *   }
     * })
    **/
    upsert<T extends NetworkingUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, NetworkingUpsertArgs<ExtArgs>>
    ): Prisma__NetworkingClient<$Result.GetResult<Prisma.$NetworkingPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Networkings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NetworkingCountArgs} args - Arguments to filter Networkings to count.
     * @example
     * // Count the number of Networkings
     * const count = await prisma.networking.count({
     *   where: {
     *     // ... the filter for the Networkings we want to count
     *   }
     * })
    **/
    count<T extends NetworkingCountArgs>(
      args?: Subset<T, NetworkingCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], NetworkingCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Networking.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NetworkingAggregateArgs} 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 NetworkingAggregateArgs>(args: Subset<T, NetworkingAggregateArgs>): Prisma.PrismaPromise<GetNetworkingAggregateType<T>>

    /**
     * Group by Networking.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NetworkingGroupByArgs} 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 NetworkingGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: NetworkingGroupByArgs['orderBy'] }
        : { orderBy?: NetworkingGroupByArgs['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, NetworkingGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetNetworkingGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Networking model
   */
  readonly fields: NetworkingFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Networking.
   * 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__NetworkingClient<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 Networking model
   */ 
  interface NetworkingFieldRefs {
    readonly id: FieldRef<"Networking", 'String'>
    readonly firstName: FieldRef<"Networking", 'String'>
    readonly lastName: FieldRef<"Networking", 'String'>
    readonly phoneNumber: FieldRef<"Networking", 'String'>
    readonly email: FieldRef<"Networking", 'String'>
    readonly activity: FieldRef<"Networking", 'String'>
    readonly needForNetworking: FieldRef<"Networking", 'String'>
    readonly createdAt: FieldRef<"Networking", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Networking findUnique
   */
  export type NetworkingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter, which Networking to fetch.
     */
    where: NetworkingWhereUniqueInput
  }

  /**
   * Networking findUniqueOrThrow
   */
  export type NetworkingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter, which Networking to fetch.
     */
    where: NetworkingWhereUniqueInput
  }

  /**
   * Networking findFirst
   */
  export type NetworkingFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter, which Networking to fetch.
     */
    where?: NetworkingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Networkings to fetch.
     */
    orderBy?: NetworkingOrderByWithRelationInput | NetworkingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Networkings.
     */
    cursor?: NetworkingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Networkings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Networkings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Networkings.
     */
    distinct?: NetworkingScalarFieldEnum | NetworkingScalarFieldEnum[]
  }

  /**
   * Networking findFirstOrThrow
   */
  export type NetworkingFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter, which Networking to fetch.
     */
    where?: NetworkingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Networkings to fetch.
     */
    orderBy?: NetworkingOrderByWithRelationInput | NetworkingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Networkings.
     */
    cursor?: NetworkingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Networkings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Networkings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Networkings.
     */
    distinct?: NetworkingScalarFieldEnum | NetworkingScalarFieldEnum[]
  }

  /**
   * Networking findMany
   */
  export type NetworkingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter, which Networkings to fetch.
     */
    where?: NetworkingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Networkings to fetch.
     */
    orderBy?: NetworkingOrderByWithRelationInput | NetworkingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Networkings.
     */
    cursor?: NetworkingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Networkings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Networkings.
     */
    skip?: number
    distinct?: NetworkingScalarFieldEnum | NetworkingScalarFieldEnum[]
  }

  /**
   * Networking create
   */
  export type NetworkingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * The data needed to create a Networking.
     */
    data: XOR<NetworkingCreateInput, NetworkingUncheckedCreateInput>
  }

  /**
   * Networking createMany
   */
  export type NetworkingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Networkings.
     */
    data: NetworkingCreateManyInput | NetworkingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Networking update
   */
  export type NetworkingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * The data needed to update a Networking.
     */
    data: XOR<NetworkingUpdateInput, NetworkingUncheckedUpdateInput>
    /**
     * Choose, which Networking to update.
     */
    where: NetworkingWhereUniqueInput
  }

  /**
   * Networking updateMany
   */
  export type NetworkingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Networkings.
     */
    data: XOR<NetworkingUpdateManyMutationInput, NetworkingUncheckedUpdateManyInput>
    /**
     * Filter which Networkings to update
     */
    where?: NetworkingWhereInput
  }

  /**
   * Networking upsert
   */
  export type NetworkingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * The filter to search for the Networking to update in case it exists.
     */
    where: NetworkingWhereUniqueInput
    /**
     * In case the Networking found by the `where` argument doesn't exist, create a new Networking with this data.
     */
    create: XOR<NetworkingCreateInput, NetworkingUncheckedCreateInput>
    /**
     * In case the Networking was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NetworkingUpdateInput, NetworkingUncheckedUpdateInput>
  }

  /**
   * Networking delete
   */
  export type NetworkingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
    /**
     * Filter which Networking to delete.
     */
    where: NetworkingWhereUniqueInput
  }

  /**
   * Networking deleteMany
   */
  export type NetworkingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Networkings to delete
     */
    where?: NetworkingWhereInput
  }

  /**
   * Networking without action
   */
  export type NetworkingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Networking
     */
    select?: NetworkingSelect<ExtArgs> | null
  }


  /**
   * Model Sourcing
   */

  export type AggregateSourcing = {
    _count: SourcingCountAggregateOutputType | null
    _min: SourcingMinAggregateOutputType | null
    _max: SourcingMaxAggregateOutputType | null
  }

  export type SourcingMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    productsToSource: string | null
    createdAt: Date | null
  }

  export type SourcingMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    productsToSource: string | null
    createdAt: Date | null
  }

  export type SourcingCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    phoneNumber: number
    email: number
    activity: number
    productsToSource: number
    createdAt: number
    _all: number
  }


  export type SourcingMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    productsToSource?: true
    createdAt?: true
  }

  export type SourcingMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    productsToSource?: true
    createdAt?: true
  }

  export type SourcingCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    productsToSource?: true
    createdAt?: true
    _all?: true
  }

  export type SourcingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Sourcing to aggregate.
     */
    where?: SourcingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sourcings to fetch.
     */
    orderBy?: SourcingOrderByWithRelationInput | SourcingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SourcingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sourcings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sourcings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Sourcings
    **/
    _count?: true | SourcingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SourcingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SourcingMaxAggregateInputType
  }

  export type GetSourcingAggregateType<T extends SourcingAggregateArgs> = {
        [P in keyof T & keyof AggregateSourcing]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSourcing[P]>
      : GetScalarType<T[P], AggregateSourcing[P]>
  }




  export type SourcingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SourcingWhereInput
    orderBy?: SourcingOrderByWithAggregationInput | SourcingOrderByWithAggregationInput[]
    by: SourcingScalarFieldEnum[] | SourcingScalarFieldEnum
    having?: SourcingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SourcingCountAggregateInputType | true
    _min?: SourcingMinAggregateInputType
    _max?: SourcingMaxAggregateInputType
  }

  export type SourcingGroupByOutputType = {
    id: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    productsToSource: string
    createdAt: Date
    _count: SourcingCountAggregateOutputType | null
    _min: SourcingMinAggregateOutputType | null
    _max: SourcingMaxAggregateOutputType | null
  }

  type GetSourcingGroupByPayload<T extends SourcingGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SourcingGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SourcingGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SourcingGroupByOutputType[P]>
            : GetScalarType<T[P], SourcingGroupByOutputType[P]>
        }
      >
    >


  export type SourcingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    productsToSource?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["sourcing"]>

  export type SourcingSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    productsToSource?: boolean
    createdAt?: boolean
  }



  export type $SourcingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Sourcing"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string
      lastName: string
      phoneNumber: string
      email: string
      activity: string
      productsToSource: string
      createdAt: Date
    }, ExtArgs["result"]["sourcing"]>
    composites: {}
  }


  type SourcingGetPayload<S extends boolean | null | undefined | SourcingDefaultArgs> = $Result.GetResult<Prisma.$SourcingPayload, S>

  type SourcingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SourcingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SourcingCountAggregateInputType | true
    }

  export interface SourcingDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Sourcing'], meta: { name: 'Sourcing' } }
    /**
     * Find zero or one Sourcing that matches the filter.
     * @param {SourcingFindUniqueArgs} args - Arguments to find a Sourcing
     * @example
     * // Get one Sourcing
     * const sourcing = await prisma.sourcing.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends SourcingFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingFindUniqueArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Sourcing that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {SourcingFindUniqueOrThrowArgs} args - Arguments to find a Sourcing
     * @example
     * // Get one Sourcing
     * const sourcing = await prisma.sourcing.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends SourcingFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Sourcing 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 {SourcingFindFirstArgs} args - Arguments to find a Sourcing
     * @example
     * // Get one Sourcing
     * const sourcing = await prisma.sourcing.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends SourcingFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingFindFirstArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Sourcing 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 {SourcingFindFirstOrThrowArgs} args - Arguments to find a Sourcing
     * @example
     * // Get one Sourcing
     * const sourcing = await prisma.sourcing.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends SourcingFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Sourcings 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 {SourcingFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Sourcings
     * const sourcings = await prisma.sourcing.findMany()
     * 
     * // Get first 10 Sourcings
     * const sourcings = await prisma.sourcing.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const sourcingWithIdOnly = await prisma.sourcing.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends SourcingFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Sourcing.
     * @param {SourcingCreateArgs} args - Arguments to create a Sourcing.
     * @example
     * // Create one Sourcing
     * const Sourcing = await prisma.sourcing.create({
     *   data: {
     *     // ... data to create a Sourcing
     *   }
     * })
     * 
    **/
    create<T extends SourcingCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingCreateArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Sourcings.
     *     @param {SourcingCreateManyArgs} args - Arguments to create many Sourcings.
     *     @example
     *     // Create many Sourcings
     *     const sourcing = await prisma.sourcing.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends SourcingCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Sourcing.
     * @param {SourcingDeleteArgs} args - Arguments to delete one Sourcing.
     * @example
     * // Delete one Sourcing
     * const Sourcing = await prisma.sourcing.delete({
     *   where: {
     *     // ... filter to delete one Sourcing
     *   }
     * })
     * 
    **/
    delete<T extends SourcingDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingDeleteArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Sourcing.
     * @param {SourcingUpdateArgs} args - Arguments to update one Sourcing.
     * @example
     * // Update one Sourcing
     * const sourcing = await prisma.sourcing.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends SourcingUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingUpdateArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Sourcings.
     * @param {SourcingDeleteManyArgs} args - Arguments to filter Sourcings to delete.
     * @example
     * // Delete a few Sourcings
     * const { count } = await prisma.sourcing.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends SourcingDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SourcingDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Sourcings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SourcingUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Sourcings
     * const sourcing = await prisma.sourcing.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends SourcingUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Sourcing.
     * @param {SourcingUpsertArgs} args - Arguments to update or create a Sourcing.
     * @example
     * // Update or create a Sourcing
     * const sourcing = await prisma.sourcing.upsert({
     *   create: {
     *     // ... data to create a Sourcing
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Sourcing we want to update
     *   }
     * })
    **/
    upsert<T extends SourcingUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, SourcingUpsertArgs<ExtArgs>>
    ): Prisma__SourcingClient<$Result.GetResult<Prisma.$SourcingPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Sourcings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SourcingCountArgs} args - Arguments to filter Sourcings to count.
     * @example
     * // Count the number of Sourcings
     * const count = await prisma.sourcing.count({
     *   where: {
     *     // ... the filter for the Sourcings we want to count
     *   }
     * })
    **/
    count<T extends SourcingCountArgs>(
      args?: Subset<T, SourcingCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SourcingCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Sourcing.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SourcingAggregateArgs} 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 SourcingAggregateArgs>(args: Subset<T, SourcingAggregateArgs>): Prisma.PrismaPromise<GetSourcingAggregateType<T>>

    /**
     * Group by Sourcing.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SourcingGroupByArgs} 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 SourcingGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SourcingGroupByArgs['orderBy'] }
        : { orderBy?: SourcingGroupByArgs['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, SourcingGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSourcingGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Sourcing model
   */
  readonly fields: SourcingFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Sourcing.
   * 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__SourcingClient<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 Sourcing model
   */ 
  interface SourcingFieldRefs {
    readonly id: FieldRef<"Sourcing", 'String'>
    readonly firstName: FieldRef<"Sourcing", 'String'>
    readonly lastName: FieldRef<"Sourcing", 'String'>
    readonly phoneNumber: FieldRef<"Sourcing", 'String'>
    readonly email: FieldRef<"Sourcing", 'String'>
    readonly activity: FieldRef<"Sourcing", 'String'>
    readonly productsToSource: FieldRef<"Sourcing", 'String'>
    readonly createdAt: FieldRef<"Sourcing", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Sourcing findUnique
   */
  export type SourcingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter, which Sourcing to fetch.
     */
    where: SourcingWhereUniqueInput
  }

  /**
   * Sourcing findUniqueOrThrow
   */
  export type SourcingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter, which Sourcing to fetch.
     */
    where: SourcingWhereUniqueInput
  }

  /**
   * Sourcing findFirst
   */
  export type SourcingFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter, which Sourcing to fetch.
     */
    where?: SourcingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sourcings to fetch.
     */
    orderBy?: SourcingOrderByWithRelationInput | SourcingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sourcings.
     */
    cursor?: SourcingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sourcings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sourcings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sourcings.
     */
    distinct?: SourcingScalarFieldEnum | SourcingScalarFieldEnum[]
  }

  /**
   * Sourcing findFirstOrThrow
   */
  export type SourcingFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter, which Sourcing to fetch.
     */
    where?: SourcingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sourcings to fetch.
     */
    orderBy?: SourcingOrderByWithRelationInput | SourcingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sourcings.
     */
    cursor?: SourcingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sourcings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sourcings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sourcings.
     */
    distinct?: SourcingScalarFieldEnum | SourcingScalarFieldEnum[]
  }

  /**
   * Sourcing findMany
   */
  export type SourcingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter, which Sourcings to fetch.
     */
    where?: SourcingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sourcings to fetch.
     */
    orderBy?: SourcingOrderByWithRelationInput | SourcingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Sourcings.
     */
    cursor?: SourcingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sourcings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sourcings.
     */
    skip?: number
    distinct?: SourcingScalarFieldEnum | SourcingScalarFieldEnum[]
  }

  /**
   * Sourcing create
   */
  export type SourcingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * The data needed to create a Sourcing.
     */
    data: XOR<SourcingCreateInput, SourcingUncheckedCreateInput>
  }

  /**
   * Sourcing createMany
   */
  export type SourcingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Sourcings.
     */
    data: SourcingCreateManyInput | SourcingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Sourcing update
   */
  export type SourcingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * The data needed to update a Sourcing.
     */
    data: XOR<SourcingUpdateInput, SourcingUncheckedUpdateInput>
    /**
     * Choose, which Sourcing to update.
     */
    where: SourcingWhereUniqueInput
  }

  /**
   * Sourcing updateMany
   */
  export type SourcingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Sourcings.
     */
    data: XOR<SourcingUpdateManyMutationInput, SourcingUncheckedUpdateManyInput>
    /**
     * Filter which Sourcings to update
     */
    where?: SourcingWhereInput
  }

  /**
   * Sourcing upsert
   */
  export type SourcingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * The filter to search for the Sourcing to update in case it exists.
     */
    where: SourcingWhereUniqueInput
    /**
     * In case the Sourcing found by the `where` argument doesn't exist, create a new Sourcing with this data.
     */
    create: XOR<SourcingCreateInput, SourcingUncheckedCreateInput>
    /**
     * In case the Sourcing was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SourcingUpdateInput, SourcingUncheckedUpdateInput>
  }

  /**
   * Sourcing delete
   */
  export type SourcingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
    /**
     * Filter which Sourcing to delete.
     */
    where: SourcingWhereUniqueInput
  }

  /**
   * Sourcing deleteMany
   */
  export type SourcingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Sourcings to delete
     */
    where?: SourcingWhereInput
  }

  /**
   * Sourcing without action
   */
  export type SourcingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Sourcing
     */
    select?: SourcingSelect<ExtArgs> | null
  }


  /**
   * Model Prospecting
   */

  export type AggregateProspecting = {
    _count: ProspectingCountAggregateOutputType | null
    _min: ProspectingMinAggregateOutputType | null
    _max: ProspectingMaxAggregateOutputType | null
  }

  export type ProspectingMinAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    needForProspecting: string | null
    createdAt: Date | null
  }

  export type ProspectingMaxAggregateOutputType = {
    id: string | null
    firstName: string | null
    lastName: string | null
    phoneNumber: string | null
    email: string | null
    activity: string | null
    needForProspecting: string | null
    createdAt: Date | null
  }

  export type ProspectingCountAggregateOutputType = {
    id: number
    firstName: number
    lastName: number
    phoneNumber: number
    email: number
    activity: number
    needForProspecting: number
    createdAt: number
    _all: number
  }


  export type ProspectingMinAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForProspecting?: true
    createdAt?: true
  }

  export type ProspectingMaxAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForProspecting?: true
    createdAt?: true
  }

  export type ProspectingCountAggregateInputType = {
    id?: true
    firstName?: true
    lastName?: true
    phoneNumber?: true
    email?: true
    activity?: true
    needForProspecting?: true
    createdAt?: true
    _all?: true
  }

  export type ProspectingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Prospecting to aggregate.
     */
    where?: ProspectingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Prospectings to fetch.
     */
    orderBy?: ProspectingOrderByWithRelationInput | ProspectingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProspectingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Prospectings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Prospectings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Prospectings
    **/
    _count?: true | ProspectingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProspectingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProspectingMaxAggregateInputType
  }

  export type GetProspectingAggregateType<T extends ProspectingAggregateArgs> = {
        [P in keyof T & keyof AggregateProspecting]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateProspecting[P]>
      : GetScalarType<T[P], AggregateProspecting[P]>
  }




  export type ProspectingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProspectingWhereInput
    orderBy?: ProspectingOrderByWithAggregationInput | ProspectingOrderByWithAggregationInput[]
    by: ProspectingScalarFieldEnum[] | ProspectingScalarFieldEnum
    having?: ProspectingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProspectingCountAggregateInputType | true
    _min?: ProspectingMinAggregateInputType
    _max?: ProspectingMaxAggregateInputType
  }

  export type ProspectingGroupByOutputType = {
    id: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForProspecting: string
    createdAt: Date
    _count: ProspectingCountAggregateOutputType | null
    _min: ProspectingMinAggregateOutputType | null
    _max: ProspectingMaxAggregateOutputType | null
  }

  type GetProspectingGroupByPayload<T extends ProspectingGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ProspectingGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ProspectingGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ProspectingGroupByOutputType[P]>
            : GetScalarType<T[P], ProspectingGroupByOutputType[P]>
        }
      >
    >


  export type ProspectingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    needForProspecting?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["prospecting"]>

  export type ProspectingSelectScalar = {
    id?: boolean
    firstName?: boolean
    lastName?: boolean
    phoneNumber?: boolean
    email?: boolean
    activity?: boolean
    needForProspecting?: boolean
    createdAt?: boolean
  }



  export type $ProspectingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Prospecting"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      firstName: string
      lastName: string
      phoneNumber: string
      email: string
      activity: string
      needForProspecting: string
      createdAt: Date
    }, ExtArgs["result"]["prospecting"]>
    composites: {}
  }


  type ProspectingGetPayload<S extends boolean | null | undefined | ProspectingDefaultArgs> = $Result.GetResult<Prisma.$ProspectingPayload, S>

  type ProspectingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ProspectingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ProspectingCountAggregateInputType | true
    }

  export interface ProspectingDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Prospecting'], meta: { name: 'Prospecting' } }
    /**
     * Find zero or one Prospecting that matches the filter.
     * @param {ProspectingFindUniqueArgs} args - Arguments to find a Prospecting
     * @example
     * // Get one Prospecting
     * const prospecting = await prisma.prospecting.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends ProspectingFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingFindUniqueArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Prospecting that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {ProspectingFindUniqueOrThrowArgs} args - Arguments to find a Prospecting
     * @example
     * // Get one Prospecting
     * const prospecting = await prisma.prospecting.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends ProspectingFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Prospecting 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 {ProspectingFindFirstArgs} args - Arguments to find a Prospecting
     * @example
     * // Get one Prospecting
     * const prospecting = await prisma.prospecting.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends ProspectingFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingFindFirstArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Prospecting 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 {ProspectingFindFirstOrThrowArgs} args - Arguments to find a Prospecting
     * @example
     * // Get one Prospecting
     * const prospecting = await prisma.prospecting.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends ProspectingFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Prospectings 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 {ProspectingFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Prospectings
     * const prospectings = await prisma.prospecting.findMany()
     * 
     * // Get first 10 Prospectings
     * const prospectings = await prisma.prospecting.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const prospectingWithIdOnly = await prisma.prospecting.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends ProspectingFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Prospecting.
     * @param {ProspectingCreateArgs} args - Arguments to create a Prospecting.
     * @example
     * // Create one Prospecting
     * const Prospecting = await prisma.prospecting.create({
     *   data: {
     *     // ... data to create a Prospecting
     *   }
     * })
     * 
    **/
    create<T extends ProspectingCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingCreateArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Prospectings.
     *     @param {ProspectingCreateManyArgs} args - Arguments to create many Prospectings.
     *     @example
     *     // Create many Prospectings
     *     const prospecting = await prisma.prospecting.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends ProspectingCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Prospecting.
     * @param {ProspectingDeleteArgs} args - Arguments to delete one Prospecting.
     * @example
     * // Delete one Prospecting
     * const Prospecting = await prisma.prospecting.delete({
     *   where: {
     *     // ... filter to delete one Prospecting
     *   }
     * })
     * 
    **/
    delete<T extends ProspectingDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingDeleteArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Prospecting.
     * @param {ProspectingUpdateArgs} args - Arguments to update one Prospecting.
     * @example
     * // Update one Prospecting
     * const prospecting = await prisma.prospecting.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ProspectingUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingUpdateArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Prospectings.
     * @param {ProspectingDeleteManyArgs} args - Arguments to filter Prospectings to delete.
     * @example
     * // Delete a few Prospectings
     * const { count } = await prisma.prospecting.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends ProspectingDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ProspectingDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Prospectings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProspectingUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Prospectings
     * const prospecting = await prisma.prospecting.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends ProspectingUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Prospecting.
     * @param {ProspectingUpsertArgs} args - Arguments to update or create a Prospecting.
     * @example
     * // Update or create a Prospecting
     * const prospecting = await prisma.prospecting.upsert({
     *   create: {
     *     // ... data to create a Prospecting
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Prospecting we want to update
     *   }
     * })
    **/
    upsert<T extends ProspectingUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, ProspectingUpsertArgs<ExtArgs>>
    ): Prisma__ProspectingClient<$Result.GetResult<Prisma.$ProspectingPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Prospectings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProspectingCountArgs} args - Arguments to filter Prospectings to count.
     * @example
     * // Count the number of Prospectings
     * const count = await prisma.prospecting.count({
     *   where: {
     *     // ... the filter for the Prospectings we want to count
     *   }
     * })
    **/
    count<T extends ProspectingCountArgs>(
      args?: Subset<T, ProspectingCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ProspectingCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Prospecting.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProspectingAggregateArgs} 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 ProspectingAggregateArgs>(args: Subset<T, ProspectingAggregateArgs>): Prisma.PrismaPromise<GetProspectingAggregateType<T>>

    /**
     * Group by Prospecting.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ProspectingGroupByArgs} 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 ProspectingGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ProspectingGroupByArgs['orderBy'] }
        : { orderBy?: ProspectingGroupByArgs['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, ProspectingGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProspectingGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Prospecting model
   */
  readonly fields: ProspectingFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Prospecting.
   * 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__ProspectingClient<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 Prospecting model
   */ 
  interface ProspectingFieldRefs {
    readonly id: FieldRef<"Prospecting", 'String'>
    readonly firstName: FieldRef<"Prospecting", 'String'>
    readonly lastName: FieldRef<"Prospecting", 'String'>
    readonly phoneNumber: FieldRef<"Prospecting", 'String'>
    readonly email: FieldRef<"Prospecting", 'String'>
    readonly activity: FieldRef<"Prospecting", 'String'>
    readonly needForProspecting: FieldRef<"Prospecting", 'String'>
    readonly createdAt: FieldRef<"Prospecting", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Prospecting findUnique
   */
  export type ProspectingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter, which Prospecting to fetch.
     */
    where: ProspectingWhereUniqueInput
  }

  /**
   * Prospecting findUniqueOrThrow
   */
  export type ProspectingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter, which Prospecting to fetch.
     */
    where: ProspectingWhereUniqueInput
  }

  /**
   * Prospecting findFirst
   */
  export type ProspectingFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter, which Prospecting to fetch.
     */
    where?: ProspectingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Prospectings to fetch.
     */
    orderBy?: ProspectingOrderByWithRelationInput | ProspectingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Prospectings.
     */
    cursor?: ProspectingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Prospectings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Prospectings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Prospectings.
     */
    distinct?: ProspectingScalarFieldEnum | ProspectingScalarFieldEnum[]
  }

  /**
   * Prospecting findFirstOrThrow
   */
  export type ProspectingFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter, which Prospecting to fetch.
     */
    where?: ProspectingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Prospectings to fetch.
     */
    orderBy?: ProspectingOrderByWithRelationInput | ProspectingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Prospectings.
     */
    cursor?: ProspectingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Prospectings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Prospectings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Prospectings.
     */
    distinct?: ProspectingScalarFieldEnum | ProspectingScalarFieldEnum[]
  }

  /**
   * Prospecting findMany
   */
  export type ProspectingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter, which Prospectings to fetch.
     */
    where?: ProspectingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Prospectings to fetch.
     */
    orderBy?: ProspectingOrderByWithRelationInput | ProspectingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Prospectings.
     */
    cursor?: ProspectingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Prospectings from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Prospectings.
     */
    skip?: number
    distinct?: ProspectingScalarFieldEnum | ProspectingScalarFieldEnum[]
  }

  /**
   * Prospecting create
   */
  export type ProspectingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * The data needed to create a Prospecting.
     */
    data: XOR<ProspectingCreateInput, ProspectingUncheckedCreateInput>
  }

  /**
   * Prospecting createMany
   */
  export type ProspectingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Prospectings.
     */
    data: ProspectingCreateManyInput | ProspectingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Prospecting update
   */
  export type ProspectingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * The data needed to update a Prospecting.
     */
    data: XOR<ProspectingUpdateInput, ProspectingUncheckedUpdateInput>
    /**
     * Choose, which Prospecting to update.
     */
    where: ProspectingWhereUniqueInput
  }

  /**
   * Prospecting updateMany
   */
  export type ProspectingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Prospectings.
     */
    data: XOR<ProspectingUpdateManyMutationInput, ProspectingUncheckedUpdateManyInput>
    /**
     * Filter which Prospectings to update
     */
    where?: ProspectingWhereInput
  }

  /**
   * Prospecting upsert
   */
  export type ProspectingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * The filter to search for the Prospecting to update in case it exists.
     */
    where: ProspectingWhereUniqueInput
    /**
     * In case the Prospecting found by the `where` argument doesn't exist, create a new Prospecting with this data.
     */
    create: XOR<ProspectingCreateInput, ProspectingUncheckedCreateInput>
    /**
     * In case the Prospecting was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProspectingUpdateInput, ProspectingUncheckedUpdateInput>
  }

  /**
   * Prospecting delete
   */
  export type ProspectingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
    /**
     * Filter which Prospecting to delete.
     */
    where: ProspectingWhereUniqueInput
  }

  /**
   * Prospecting deleteMany
   */
  export type ProspectingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Prospectings to delete
     */
    where?: ProspectingWhereInput
  }

  /**
   * Prospecting without action
   */
  export type ProspectingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Prospecting
     */
    select?: ProspectingSelect<ExtArgs> | null
  }


  /**
   * Model SmsLog
   */

  export type AggregateSmsLog = {
    _count: SmsLogCountAggregateOutputType | null
    _avg: SmsLogAvgAggregateOutputType | null
    _sum: SmsLogSumAggregateOutputType | null
    _min: SmsLogMinAggregateOutputType | null
    _max: SmsLogMaxAggregateOutputType | null
  }

  export type SmsLogAvgAggregateOutputType = {
    statusCode: number | null
  }

  export type SmsLogSumAggregateOutputType = {
    statusCode: number | null
  }

  export type SmsLogMinAggregateOutputType = {
    id: string | null
    createdAt: Date | null
    gateway: string | null
    senderId: string | null
    recipient: string | null
    content: string | null
    statusCode: number | null
    statusText: string | null
    requestUrl: string | null
    requestBody: string | null
    responseBody: string | null
    errorMessage: string | null
    userId: string | null
  }

  export type SmsLogMaxAggregateOutputType = {
    id: string | null
    createdAt: Date | null
    gateway: string | null
    senderId: string | null
    recipient: string | null
    content: string | null
    statusCode: number | null
    statusText: string | null
    requestUrl: string | null
    requestBody: string | null
    responseBody: string | null
    errorMessage: string | null
    userId: string | null
  }

  export type SmsLogCountAggregateOutputType = {
    id: number
    createdAt: number
    gateway: number
    senderId: number
    recipient: number
    content: number
    statusCode: number
    statusText: number
    requestUrl: number
    requestBody: number
    responseBody: number
    errorMessage: number
    meta: number
    userId: number
    _all: number
  }


  export type SmsLogAvgAggregateInputType = {
    statusCode?: true
  }

  export type SmsLogSumAggregateInputType = {
    statusCode?: true
  }

  export type SmsLogMinAggregateInputType = {
    id?: true
    createdAt?: true
    gateway?: true
    senderId?: true
    recipient?: true
    content?: true
    statusCode?: true
    statusText?: true
    requestUrl?: true
    requestBody?: true
    responseBody?: true
    errorMessage?: true
    userId?: true
  }

  export type SmsLogMaxAggregateInputType = {
    id?: true
    createdAt?: true
    gateway?: true
    senderId?: true
    recipient?: true
    content?: true
    statusCode?: true
    statusText?: true
    requestUrl?: true
    requestBody?: true
    responseBody?: true
    errorMessage?: true
    userId?: true
  }

  export type SmsLogCountAggregateInputType = {
    id?: true
    createdAt?: true
    gateway?: true
    senderId?: true
    recipient?: true
    content?: true
    statusCode?: true
    statusText?: true
    requestUrl?: true
    requestBody?: true
    responseBody?: true
    errorMessage?: true
    meta?: true
    userId?: true
    _all?: true
  }

  export type SmsLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SmsLog to aggregate.
     */
    where?: SmsLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsLogs to fetch.
     */
    orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SmsLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SmsLogs
    **/
    _count?: true | SmsLogCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SmsLogAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SmsLogSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SmsLogMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SmsLogMaxAggregateInputType
  }

  export type GetSmsLogAggregateType<T extends SmsLogAggregateArgs> = {
        [P in keyof T & keyof AggregateSmsLog]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSmsLog[P]>
      : GetScalarType<T[P], AggregateSmsLog[P]>
  }




  export type SmsLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SmsLogWhereInput
    orderBy?: SmsLogOrderByWithAggregationInput | SmsLogOrderByWithAggregationInput[]
    by: SmsLogScalarFieldEnum[] | SmsLogScalarFieldEnum
    having?: SmsLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SmsLogCountAggregateInputType | true
    _avg?: SmsLogAvgAggregateInputType
    _sum?: SmsLogSumAggregateInputType
    _min?: SmsLogMinAggregateInputType
    _max?: SmsLogMaxAggregateInputType
  }

  export type SmsLogGroupByOutputType = {
    id: string
    createdAt: Date
    gateway: string
    senderId: string
    recipient: string
    content: string
    statusCode: number | null
    statusText: string | null
    requestUrl: string | null
    requestBody: string | null
    responseBody: string | null
    errorMessage: string | null
    meta: JsonValue | null
    userId: string | null
    _count: SmsLogCountAggregateOutputType | null
    _avg: SmsLogAvgAggregateOutputType | null
    _sum: SmsLogSumAggregateOutputType | null
    _min: SmsLogMinAggregateOutputType | null
    _max: SmsLogMaxAggregateOutputType | null
  }

  type GetSmsLogGroupByPayload<T extends SmsLogGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SmsLogGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SmsLogGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SmsLogGroupByOutputType[P]>
            : GetScalarType<T[P], SmsLogGroupByOutputType[P]>
        }
      >
    >


  export type SmsLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    createdAt?: boolean
    gateway?: boolean
    senderId?: boolean
    recipient?: boolean
    content?: boolean
    statusCode?: boolean
    statusText?: boolean
    requestUrl?: boolean
    requestBody?: boolean
    responseBody?: boolean
    errorMessage?: boolean
    meta?: boolean
    userId?: boolean
  }, ExtArgs["result"]["smsLog"]>

  export type SmsLogSelectScalar = {
    id?: boolean
    createdAt?: boolean
    gateway?: boolean
    senderId?: boolean
    recipient?: boolean
    content?: boolean
    statusCode?: boolean
    statusText?: boolean
    requestUrl?: boolean
    requestBody?: boolean
    responseBody?: boolean
    errorMessage?: boolean
    meta?: boolean
    userId?: boolean
  }



  export type $SmsLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SmsLog"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      createdAt: Date
      gateway: string
      senderId: string
      recipient: string
      content: string
      statusCode: number | null
      statusText: string | null
      requestUrl: string | null
      requestBody: string | null
      responseBody: string | null
      errorMessage: string | null
      meta: Prisma.JsonValue | null
      userId: string | null
    }, ExtArgs["result"]["smsLog"]>
    composites: {}
  }


  type SmsLogGetPayload<S extends boolean | null | undefined | SmsLogDefaultArgs> = $Result.GetResult<Prisma.$SmsLogPayload, S>

  type SmsLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SmsLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SmsLogCountAggregateInputType | true
    }

  export interface SmsLogDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['SmsLog'], meta: { name: 'SmsLog' } }
    /**
     * Find zero or one SmsLog that matches the filter.
     * @param {SmsLogFindUniqueArgs} args - Arguments to find a SmsLog
     * @example
     * // Get one SmsLog
     * const smsLog = await prisma.smsLog.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends SmsLogFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogFindUniqueArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one SmsLog that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {SmsLogFindUniqueOrThrowArgs} args - Arguments to find a SmsLog
     * @example
     * // Get one SmsLog
     * const smsLog = await prisma.smsLog.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends SmsLogFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first SmsLog 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 {SmsLogFindFirstArgs} args - Arguments to find a SmsLog
     * @example
     * // Get one SmsLog
     * const smsLog = await prisma.smsLog.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends SmsLogFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogFindFirstArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first SmsLog 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 {SmsLogFindFirstOrThrowArgs} args - Arguments to find a SmsLog
     * @example
     * // Get one SmsLog
     * const smsLog = await prisma.smsLog.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends SmsLogFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more SmsLogs 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 {SmsLogFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all SmsLogs
     * const smsLogs = await prisma.smsLog.findMany()
     * 
     * // Get first 10 SmsLogs
     * const smsLogs = await prisma.smsLog.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const smsLogWithIdOnly = await prisma.smsLog.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends SmsLogFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a SmsLog.
     * @param {SmsLogCreateArgs} args - Arguments to create a SmsLog.
     * @example
     * // Create one SmsLog
     * const SmsLog = await prisma.smsLog.create({
     *   data: {
     *     // ... data to create a SmsLog
     *   }
     * })
     * 
    **/
    create<T extends SmsLogCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogCreateArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many SmsLogs.
     *     @param {SmsLogCreateManyArgs} args - Arguments to create many SmsLogs.
     *     @example
     *     // Create many SmsLogs
     *     const smsLog = await prisma.smsLog.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends SmsLogCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a SmsLog.
     * @param {SmsLogDeleteArgs} args - Arguments to delete one SmsLog.
     * @example
     * // Delete one SmsLog
     * const SmsLog = await prisma.smsLog.delete({
     *   where: {
     *     // ... filter to delete one SmsLog
     *   }
     * })
     * 
    **/
    delete<T extends SmsLogDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogDeleteArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one SmsLog.
     * @param {SmsLogUpdateArgs} args - Arguments to update one SmsLog.
     * @example
     * // Update one SmsLog
     * const smsLog = await prisma.smsLog.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends SmsLogUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogUpdateArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more SmsLogs.
     * @param {SmsLogDeleteManyArgs} args - Arguments to filter SmsLogs to delete.
     * @example
     * // Delete a few SmsLogs
     * const { count } = await prisma.smsLog.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends SmsLogDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SmsLogDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more SmsLogs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsLogUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many SmsLogs
     * const smsLog = await prisma.smsLog.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends SmsLogUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one SmsLog.
     * @param {SmsLogUpsertArgs} args - Arguments to update or create a SmsLog.
     * @example
     * // Update or create a SmsLog
     * const smsLog = await prisma.smsLog.upsert({
     *   create: {
     *     // ... data to create a SmsLog
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the SmsLog we want to update
     *   }
     * })
    **/
    upsert<T extends SmsLogUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, SmsLogUpsertArgs<ExtArgs>>
    ): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of SmsLogs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsLogCountArgs} args - Arguments to filter SmsLogs to count.
     * @example
     * // Count the number of SmsLogs
     * const count = await prisma.smsLog.count({
     *   where: {
     *     // ... the filter for the SmsLogs we want to count
     *   }
     * })
    **/
    count<T extends SmsLogCountArgs>(
      args?: Subset<T, SmsLogCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SmsLogCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a SmsLog.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsLogAggregateArgs} 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 SmsLogAggregateArgs>(args: Subset<T, SmsLogAggregateArgs>): Prisma.PrismaPromise<GetSmsLogAggregateType<T>>

    /**
     * Group by SmsLog.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsLogGroupByArgs} 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 SmsLogGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SmsLogGroupByArgs['orderBy'] }
        : { orderBy?: SmsLogGroupByArgs['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, SmsLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSmsLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the SmsLog model
   */
  readonly fields: SmsLogFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for SmsLog.
   * 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__SmsLogClient<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 SmsLog model
   */ 
  interface SmsLogFieldRefs {
    readonly id: FieldRef<"SmsLog", 'String'>
    readonly createdAt: FieldRef<"SmsLog", 'DateTime'>
    readonly gateway: FieldRef<"SmsLog", 'String'>
    readonly senderId: FieldRef<"SmsLog", 'String'>
    readonly recipient: FieldRef<"SmsLog", 'String'>
    readonly content: FieldRef<"SmsLog", 'String'>
    readonly statusCode: FieldRef<"SmsLog", 'Int'>
    readonly statusText: FieldRef<"SmsLog", 'String'>
    readonly requestUrl: FieldRef<"SmsLog", 'String'>
    readonly requestBody: FieldRef<"SmsLog", 'String'>
    readonly responseBody: FieldRef<"SmsLog", 'String'>
    readonly errorMessage: FieldRef<"SmsLog", 'String'>
    readonly meta: FieldRef<"SmsLog", 'Json'>
    readonly userId: FieldRef<"SmsLog", 'String'>
  }
    

  // Custom InputTypes
  /**
   * SmsLog findUnique
   */
  export type SmsLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter, which SmsLog to fetch.
     */
    where: SmsLogWhereUniqueInput
  }

  /**
   * SmsLog findUniqueOrThrow
   */
  export type SmsLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter, which SmsLog to fetch.
     */
    where: SmsLogWhereUniqueInput
  }

  /**
   * SmsLog findFirst
   */
  export type SmsLogFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter, which SmsLog to fetch.
     */
    where?: SmsLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsLogs to fetch.
     */
    orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SmsLogs.
     */
    cursor?: SmsLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SmsLogs.
     */
    distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
  }

  /**
   * SmsLog findFirstOrThrow
   */
  export type SmsLogFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter, which SmsLog to fetch.
     */
    where?: SmsLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsLogs to fetch.
     */
    orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SmsLogs.
     */
    cursor?: SmsLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SmsLogs.
     */
    distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
  }

  /**
   * SmsLog findMany
   */
  export type SmsLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter, which SmsLogs to fetch.
     */
    where?: SmsLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsLogs to fetch.
     */
    orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SmsLogs.
     */
    cursor?: SmsLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsLogs.
     */
    skip?: number
    distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
  }

  /**
   * SmsLog create
   */
  export type SmsLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * The data needed to create a SmsLog.
     */
    data: XOR<SmsLogCreateInput, SmsLogUncheckedCreateInput>
  }

  /**
   * SmsLog createMany
   */
  export type SmsLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many SmsLogs.
     */
    data: SmsLogCreateManyInput | SmsLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * SmsLog update
   */
  export type SmsLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * The data needed to update a SmsLog.
     */
    data: XOR<SmsLogUpdateInput, SmsLogUncheckedUpdateInput>
    /**
     * Choose, which SmsLog to update.
     */
    where: SmsLogWhereUniqueInput
  }

  /**
   * SmsLog updateMany
   */
  export type SmsLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SmsLogs.
     */
    data: XOR<SmsLogUpdateManyMutationInput, SmsLogUncheckedUpdateManyInput>
    /**
     * Filter which SmsLogs to update
     */
    where?: SmsLogWhereInput
  }

  /**
   * SmsLog upsert
   */
  export type SmsLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * The filter to search for the SmsLog to update in case it exists.
     */
    where: SmsLogWhereUniqueInput
    /**
     * In case the SmsLog found by the `where` argument doesn't exist, create a new SmsLog with this data.
     */
    create: XOR<SmsLogCreateInput, SmsLogUncheckedCreateInput>
    /**
     * In case the SmsLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SmsLogUpdateInput, SmsLogUncheckedUpdateInput>
  }

  /**
   * SmsLog delete
   */
  export type SmsLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
    /**
     * Filter which SmsLog to delete.
     */
    where: SmsLogWhereUniqueInput
  }

  /**
   * SmsLog deleteMany
   */
  export type SmsLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SmsLogs to delete
     */
    where?: SmsLogWhereInput
  }

  /**
   * SmsLog without action
   */
  export type SmsLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsLog
     */
    select?: SmsLogSelect<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const CcisScalarFieldEnum: {
    id: 'id',
    presentation: 'presentation',
    termsOfService: 'termsOfService',
    privacyPolicy: 'privacyPolicy'
  };

  export type CcisScalarFieldEnum = (typeof CcisScalarFieldEnum)[keyof typeof CcisScalarFieldEnum]


  export const TurnoverScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type TurnoverScalarFieldEnum = (typeof TurnoverScalarFieldEnum)[keyof typeof TurnoverScalarFieldEnum]


  export const NEmployeesScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type NEmployeesScalarFieldEnum = (typeof NEmployeesScalarFieldEnum)[keyof typeof NEmployeesScalarFieldEnum]


  export const CityScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type CityScalarFieldEnum = (typeof CityScalarFieldEnum)[keyof typeof CityScalarFieldEnum]


  export const PositionScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type PositionScalarFieldEnum = (typeof PositionScalarFieldEnum)[keyof typeof PositionScalarFieldEnum]


  export const ActivityFamilyScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type ActivityFamilyScalarFieldEnum = (typeof ActivityFamilyScalarFieldEnum)[keyof typeof ActivityFamilyScalarFieldEnum]


  export const ActivityScalarFieldEnum: {
    id: 'id',
    name: 'name',
    activityFamilyId: 'activityFamilyId'
  };

  export type ActivityScalarFieldEnum = (typeof ActivityScalarFieldEnum)[keyof typeof ActivityScalarFieldEnum]


  export const ExpertiseAreaScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type ExpertiseAreaScalarFieldEnum = (typeof ExpertiseAreaScalarFieldEnum)[keyof typeof ExpertiseAreaScalarFieldEnum]


  export const InterestAreaScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type InterestAreaScalarFieldEnum = (typeof InterestAreaScalarFieldEnum)[keyof typeof InterestAreaScalarFieldEnum]


  export const ProvinceScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type ProvinceScalarFieldEnum = (typeof ProvinceScalarFieldEnum)[keyof typeof ProvinceScalarFieldEnum]


  export const CategoryScalarFieldEnum: {
    id: 'id',
    name: 'name',
    nameAr: 'nameAr'
  };

  export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum]


  export const CommissionScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description'
  };

  export type CommissionScalarFieldEnum = (typeof CommissionScalarFieldEnum)[keyof typeof CommissionScalarFieldEnum]


  export const MandateScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type MandateScalarFieldEnum = (typeof MandateScalarFieldEnum)[keyof typeof MandateScalarFieldEnum]


  export const CollegeScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type CollegeScalarFieldEnum = (typeof CollegeScalarFieldEnum)[keyof typeof CollegeScalarFieldEnum]


  export const ElectedMemberScalarFieldEnum: {
    id: 'id',
    image: 'image',
    fullName: 'fullName',
    positionId: 'positionId',
    activityFamilyId: 'activityFamilyId',
    activityId: 'activityId',
    phoneNumber: 'phoneNumber',
    gsm: 'gsm',
    fax: 'fax',
    email: 'email',
    adresse: 'adresse',
    collegeId: 'collegeId',
    provinceId: 'provinceId',
    mandateId: 'mandateId',
    commissions: 'commissions',
    details: 'details'
  };

  export type ElectedMemberScalarFieldEnum = (typeof ElectedMemberScalarFieldEnum)[keyof typeof ElectedMemberScalarFieldEnum]


  export const UserScalarFieldEnum: {
    id: 'id',
    civility: 'civility',
    firstName: 'firstName',
    lastName: 'lastName',
    email: 'email',
    password: 'password',
    cityId: 'cityId',
    positionId: 'positionId',
    phoneNumber: 'phoneNumber',
    expertiseAreas: 'expertiseAreas',
    interestAreas: 'interestAreas',
    bio: 'bio',
    companyId: 'companyId',
    department: 'department',
    service: 'service',
    adresse: 'adresse',
    collegeId: 'collegeId',
    provinceId: 'provinceId',
    mandateId: 'mandateId',
    commissions: 'commissions',
    details: 'details',
    active: 'active',
    member: 'member',
    role: 'role',
    permissions: 'permissions',
    resetPasswordCode: 'resetPasswordCode',
    resetPasswordAt: 'resetPasswordAt',
    loggedInAt: 'loggedInAt',
    createdAt: 'createdAt'
  };

  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]


  export const NotificationScalarFieldEnum: {
    id: 'id',
    title: 'title',
    content: 'content',
    source: 'source',
    createdAt: 'createdAt',
    isRead: 'isRead',
    userId: 'userId'
  };

  export type NotificationScalarFieldEnum = (typeof NotificationScalarFieldEnum)[keyof typeof NotificationScalarFieldEnum]


  export const CompanyScalarFieldEnum: {
    id: 'id',
    logo: 'logo',
    name: 'name',
    legalForm: 'legalForm',
    cityId: 'cityId',
    address: 'address',
    phoneNumber: 'phoneNumber',
    fax: 'fax',
    email: 'email',
    website: 'website',
    linkedin: 'linkedin',
    facebook: 'facebook',
    contactFirstName: 'contactFirstName',
    contactLastName: 'contactLastName',
    contactEmail: 'contactEmail',
    contactPositionId: 'contactPositionId',
    contactLinkedin: 'contactLinkedin',
    contactFacebook: 'contactFacebook',
    businessLicense: 'businessLicense',
    numRC: 'numRC',
    numICE: 'numICE',
    capital: 'capital',
    turnoverId: 'turnoverId',
    nEmployeesId: 'nEmployeesId',
    activitiesFamilies: 'activitiesFamilies',
    activities: 'activities',
    importCountries: 'importCountries',
    exportCountries: 'exportCountries',
    verified: 'verified',
    active: 'active',
    partner: 'partner',
    contributor: 'contributor',
    createdAt: 'createdAt'
  };

  export type CompanyScalarFieldEnum = (typeof CompanyScalarFieldEnum)[keyof typeof CompanyScalarFieldEnum]


  export const ConnectionScalarFieldEnum: {
    id: 'id',
    senderId: 'senderId',
    receiverId: 'receiverId',
    accepted: 'accepted',
    createdAt: 'createdAt'
  };

  export type ConnectionScalarFieldEnum = (typeof ConnectionScalarFieldEnum)[keyof typeof ConnectionScalarFieldEnum]


  export const MessageScalarFieldEnum: {
    id: 'id',
    senderId: 'senderId',
    receiverId: 'receiverId',
    message: 'message',
    read: 'read',
    createdAt: 'createdAt'
  };

  export type MessageScalarFieldEnum = (typeof MessageScalarFieldEnum)[keyof typeof MessageScalarFieldEnum]


  export const OpportunityScalarFieldEnum: {
    id: 'id',
    title: 'title',
    description: 'description',
    companyName: 'companyName',
    activitiesFamilies: 'activitiesFamilies',
    activities: 'activities',
    country: 'country',
    address: 'address',
    requirements: 'requirements',
    contactEmail: 'contactEmail',
    contactPhoneNumber: 'contactPhoneNumber',
    creatorId: 'creatorId',
    document: 'document',
    verified: 'verified',
    active: 'active',
    validityDate: 'validityDate',
    createdAt: 'createdAt'
  };

  export type OpportunityScalarFieldEnum = (typeof OpportunityScalarFieldEnum)[keyof typeof OpportunityScalarFieldEnum]


  export const OpportunityLikeScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    opportunityId: 'opportunityId'
  };

  export type OpportunityLikeScalarFieldEnum = (typeof OpportunityLikeScalarFieldEnum)[keyof typeof OpportunityLikeScalarFieldEnum]


  export const OpportunityCommentScalarFieldEnum: {
    id: 'id',
    content: 'content',
    userId: 'userId',
    opportunityId: 'opportunityId',
    createdAt: 'createdAt'
  };

  export type OpportunityCommentScalarFieldEnum = (typeof OpportunityCommentScalarFieldEnum)[keyof typeof OpportunityCommentScalarFieldEnum]


  export const EventScalarFieldEnum: {
    id: 'id',
    title: 'title',
    briefDescription: 'briefDescription',
    description: 'description',
    date: 'date',
    active: 'active',
    images: 'images'
  };

  export type EventScalarFieldEnum = (typeof EventScalarFieldEnum)[keyof typeof EventScalarFieldEnum]


  export const EventLikeScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    eventId: 'eventId'
  };

  export type EventLikeScalarFieldEnum = (typeof EventLikeScalarFieldEnum)[keyof typeof EventLikeScalarFieldEnum]


  export const EventCommentScalarFieldEnum: {
    id: 'id',
    content: 'content',
    userId: 'userId',
    eventId: 'eventId',
    createdAt: 'createdAt'
  };

  export type EventCommentScalarFieldEnum = (typeof EventCommentScalarFieldEnum)[keyof typeof EventCommentScalarFieldEnum]


  export const AppointmentScalarFieldEnum: {
    id: 'id',
    title: 'title',
    briefDescription: 'briefDescription',
    description: 'description',
    date: 'date',
    time: 'time',
    activationDate: 'activationDate',
    address: 'address',
    active: 'active',
    images: 'images'
  };

  export type AppointmentScalarFieldEnum = (typeof AppointmentScalarFieldEnum)[keyof typeof AppointmentScalarFieldEnum]


  export const AppointmentLikeScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    appointmentId: 'appointmentId'
  };

  export type AppointmentLikeScalarFieldEnum = (typeof AppointmentLikeScalarFieldEnum)[keyof typeof AppointmentLikeScalarFieldEnum]


  export const AppointmentCommentScalarFieldEnum: {
    id: 'id',
    content: 'content',
    userId: 'userId',
    appointmentId: 'appointmentId',
    createdAt: 'createdAt'
  };

  export type AppointmentCommentScalarFieldEnum = (typeof AppointmentCommentScalarFieldEnum)[keyof typeof AppointmentCommentScalarFieldEnum]


  export const AppointmentRegistrationScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    appointmentId: 'appointmentId',
    createdAt: 'createdAt'
  };

  export type AppointmentRegistrationScalarFieldEnum = (typeof AppointmentRegistrationScalarFieldEnum)[keyof typeof AppointmentRegistrationScalarFieldEnum]


  export const AlbumScalarFieldEnum: {
    id: 'id',
    title: 'title',
    date: 'date',
    images: 'images'
  };

  export type AlbumScalarFieldEnum = (typeof AlbumScalarFieldEnum)[keyof typeof AlbumScalarFieldEnum]


  export const VideoScalarFieldEnum: {
    id: 'id',
    title: 'title',
    date: 'date',
    link: 'link'
  };

  export type VideoScalarFieldEnum = (typeof VideoScalarFieldEnum)[keyof typeof VideoScalarFieldEnum]


  export const EditionScalarFieldEnum: {
    id: 'id',
    title: 'title',
    categoryId: 'categoryId',
    document: 'document',
    image: 'image'
  };

  export type EditionScalarFieldEnum = (typeof EditionScalarFieldEnum)[keyof typeof EditionScalarFieldEnum]


  export const TrainingScalarFieldEnum: {
    id: 'id',
    title: 'title',
    place: 'place',
    date: 'date',
    email: 'email',
    phoneNumber: 'phoneNumber',
    website: 'website',
    type: 'type',
    description: 'description',
    document: 'document'
  };

  export type TrainingScalarFieldEnum = (typeof TrainingScalarFieldEnum)[keyof typeof TrainingScalarFieldEnum]


  export const FairScalarFieldEnum: {
    id: 'id',
    title: 'title',
    country: 'country',
    place: 'place',
    startDate: 'startDate',
    endDate: 'endDate',
    sector: 'sector',
    organizer: 'organizer',
    phoneNumber: 'phoneNumber',
    fax: 'fax',
    email: 'email',
    website: 'website'
  };

  export type FairScalarFieldEnum = (typeof FairScalarFieldEnum)[keyof typeof FairScalarFieldEnum]


  export const BusinessPlanScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    nationality: 'nationality',
    phoneNumber: 'phoneNumber',
    email: 'email',
    projectIdea: 'projectIdea',
    location: 'location',
    educationAndExperience: 'educationAndExperience',
    financingPlan: 'financingPlan',
    createdAt: 'createdAt'
  };

  export type BusinessPlanScalarFieldEnum = (typeof BusinessPlanScalarFieldEnum)[keyof typeof BusinessPlanScalarFieldEnum]


  export const MarketResearchScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    phoneNumber: 'phoneNumber',
    email: 'email',
    address: 'address',
    city: 'city',
    state: 'state',
    zipCode: 'zipCode',
    country: 'country',
    projectIdea: 'projectIdea',
    educationAndExperience: 'educationAndExperience',
    createdAt: 'createdAt'
  };

  export type MarketResearchScalarFieldEnum = (typeof MarketResearchScalarFieldEnum)[keyof typeof MarketResearchScalarFieldEnum]


  export const NetworkingScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    phoneNumber: 'phoneNumber',
    email: 'email',
    activity: 'activity',
    needForNetworking: 'needForNetworking',
    createdAt: 'createdAt'
  };

  export type NetworkingScalarFieldEnum = (typeof NetworkingScalarFieldEnum)[keyof typeof NetworkingScalarFieldEnum]


  export const SourcingScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    phoneNumber: 'phoneNumber',
    email: 'email',
    activity: 'activity',
    productsToSource: 'productsToSource',
    createdAt: 'createdAt'
  };

  export type SourcingScalarFieldEnum = (typeof SourcingScalarFieldEnum)[keyof typeof SourcingScalarFieldEnum]


  export const ProspectingScalarFieldEnum: {
    id: 'id',
    firstName: 'firstName',
    lastName: 'lastName',
    phoneNumber: 'phoneNumber',
    email: 'email',
    activity: 'activity',
    needForProspecting: 'needForProspecting',
    createdAt: 'createdAt'
  };

  export type ProspectingScalarFieldEnum = (typeof ProspectingScalarFieldEnum)[keyof typeof ProspectingScalarFieldEnum]


  export const SmsLogScalarFieldEnum: {
    id: 'id',
    createdAt: 'createdAt',
    gateway: 'gateway',
    senderId: 'senderId',
    recipient: 'recipient',
    content: 'content',
    statusCode: 'statusCode',
    statusText: 'statusText',
    requestUrl: 'requestUrl',
    requestBody: 'requestBody',
    responseBody: 'responseBody',
    errorMessage: 'errorMessage',
    meta: 'meta',
    userId: 'userId'
  };

  export type SmsLogScalarFieldEnum = (typeof SmsLogScalarFieldEnum)[keyof typeof SmsLogScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const NullableJsonNullValueInput: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull
  };

  export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

  export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

  export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]


  /**
   * Field references 
   */


  /**
   * Reference to a field of type '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 'Civility'
   */
  export type EnumCivilityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Civility'>
    


  /**
   * Reference to a field of type 'Civility[]'
   */
  export type ListEnumCivilityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Civility[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'Role'
   */
  export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
    


  /**
   * Reference to a field of type 'Role[]'
   */
  export type ListEnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role[]'>
    


  /**
   * Reference to a field of type 'Permission[]'
   */
  export type ListEnumPermissionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Permission[]'>
    


  /**
   * Reference to a field of type 'Permission'
   */
  export type EnumPermissionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Permission'>
    


  /**
   * 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 'Source'
   */
  export type EnumSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Source'>
    


  /**
   * Reference to a field of type 'Source[]'
   */
  export type ListEnumSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Source[]'>
    


  /**
   * Reference to a field of type 'LegalForm'
   */
  export type EnumLegalFormFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LegalForm'>
    


  /**
   * Reference to a field of type 'LegalForm[]'
   */
  export type ListEnumLegalFormFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LegalForm[]'>
    


  /**
   * 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 'TrainingType'
   */
  export type EnumTrainingTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TrainingType'>
    


  /**
   * Reference to a field of type 'TrainingType[]'
   */
  export type ListEnumTrainingTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TrainingType[]'>
    


  /**
   * 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 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    
  /**
   * Deep Input Types
   */


  export type CcisWhereInput = {
    AND?: CcisWhereInput | CcisWhereInput[]
    OR?: CcisWhereInput[]
    NOT?: CcisWhereInput | CcisWhereInput[]
    id?: StringFilter<"Ccis"> | string
    presentation?: StringFilter<"Ccis"> | string
    termsOfService?: StringFilter<"Ccis"> | string
    privacyPolicy?: StringFilter<"Ccis"> | string
  }

  export type CcisOrderByWithRelationInput = {
    id?: SortOrder
    presentation?: SortOrder
    termsOfService?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type CcisWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CcisWhereInput | CcisWhereInput[]
    OR?: CcisWhereInput[]
    NOT?: CcisWhereInput | CcisWhereInput[]
    presentation?: StringFilter<"Ccis"> | string
    termsOfService?: StringFilter<"Ccis"> | string
    privacyPolicy?: StringFilter<"Ccis"> | string
  }, "id">

  export type CcisOrderByWithAggregationInput = {
    id?: SortOrder
    presentation?: SortOrder
    termsOfService?: SortOrder
    privacyPolicy?: SortOrder
    _count?: CcisCountOrderByAggregateInput
    _max?: CcisMaxOrderByAggregateInput
    _min?: CcisMinOrderByAggregateInput
  }

  export type CcisScalarWhereWithAggregatesInput = {
    AND?: CcisScalarWhereWithAggregatesInput | CcisScalarWhereWithAggregatesInput[]
    OR?: CcisScalarWhereWithAggregatesInput[]
    NOT?: CcisScalarWhereWithAggregatesInput | CcisScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Ccis"> | string
    presentation?: StringWithAggregatesFilter<"Ccis"> | string
    termsOfService?: StringWithAggregatesFilter<"Ccis"> | string
    privacyPolicy?: StringWithAggregatesFilter<"Ccis"> | string
  }

  export type TurnoverWhereInput = {
    AND?: TurnoverWhereInput | TurnoverWhereInput[]
    OR?: TurnoverWhereInput[]
    NOT?: TurnoverWhereInput | TurnoverWhereInput[]
    id?: StringFilter<"Turnover"> | string
    name?: StringFilter<"Turnover"> | string
    companies?: CompanyListRelationFilter
  }

  export type TurnoverOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    companies?: CompanyOrderByRelationAggregateInput
  }

  export type TurnoverWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TurnoverWhereInput | TurnoverWhereInput[]
    OR?: TurnoverWhereInput[]
    NOT?: TurnoverWhereInput | TurnoverWhereInput[]
    name?: StringFilter<"Turnover"> | string
    companies?: CompanyListRelationFilter
  }, "id">

  export type TurnoverOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: TurnoverCountOrderByAggregateInput
    _max?: TurnoverMaxOrderByAggregateInput
    _min?: TurnoverMinOrderByAggregateInput
  }

  export type TurnoverScalarWhereWithAggregatesInput = {
    AND?: TurnoverScalarWhereWithAggregatesInput | TurnoverScalarWhereWithAggregatesInput[]
    OR?: TurnoverScalarWhereWithAggregatesInput[]
    NOT?: TurnoverScalarWhereWithAggregatesInput | TurnoverScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Turnover"> | string
    name?: StringWithAggregatesFilter<"Turnover"> | string
  }

  export type NEmployeesWhereInput = {
    AND?: NEmployeesWhereInput | NEmployeesWhereInput[]
    OR?: NEmployeesWhereInput[]
    NOT?: NEmployeesWhereInput | NEmployeesWhereInput[]
    id?: StringFilter<"NEmployees"> | string
    name?: StringFilter<"NEmployees"> | string
    companies?: CompanyListRelationFilter
  }

  export type NEmployeesOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    companies?: CompanyOrderByRelationAggregateInput
  }

  export type NEmployeesWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: NEmployeesWhereInput | NEmployeesWhereInput[]
    OR?: NEmployeesWhereInput[]
    NOT?: NEmployeesWhereInput | NEmployeesWhereInput[]
    name?: StringFilter<"NEmployees"> | string
    companies?: CompanyListRelationFilter
  }, "id">

  export type NEmployeesOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: NEmployeesCountOrderByAggregateInput
    _max?: NEmployeesMaxOrderByAggregateInput
    _min?: NEmployeesMinOrderByAggregateInput
  }

  export type NEmployeesScalarWhereWithAggregatesInput = {
    AND?: NEmployeesScalarWhereWithAggregatesInput | NEmployeesScalarWhereWithAggregatesInput[]
    OR?: NEmployeesScalarWhereWithAggregatesInput[]
    NOT?: NEmployeesScalarWhereWithAggregatesInput | NEmployeesScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"NEmployees"> | string
    name?: StringWithAggregatesFilter<"NEmployees"> | string
  }

  export type CityWhereInput = {
    AND?: CityWhereInput | CityWhereInput[]
    OR?: CityWhereInput[]
    NOT?: CityWhereInput | CityWhereInput[]
    id?: StringFilter<"City"> | string
    name?: StringFilter<"City"> | string
    users?: UserListRelationFilter
    companies?: CompanyListRelationFilter
  }

  export type CityOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    users?: UserOrderByRelationAggregateInput
    companies?: CompanyOrderByRelationAggregateInput
  }

  export type CityWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CityWhereInput | CityWhereInput[]
    OR?: CityWhereInput[]
    NOT?: CityWhereInput | CityWhereInput[]
    name?: StringFilter<"City"> | string
    users?: UserListRelationFilter
    companies?: CompanyListRelationFilter
  }, "id">

  export type CityOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: CityCountOrderByAggregateInput
    _max?: CityMaxOrderByAggregateInput
    _min?: CityMinOrderByAggregateInput
  }

  export type CityScalarWhereWithAggregatesInput = {
    AND?: CityScalarWhereWithAggregatesInput | CityScalarWhereWithAggregatesInput[]
    OR?: CityScalarWhereWithAggregatesInput[]
    NOT?: CityScalarWhereWithAggregatesInput | CityScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"City"> | string
    name?: StringWithAggregatesFilter<"City"> | string
  }

  export type PositionWhereInput = {
    AND?: PositionWhereInput | PositionWhereInput[]
    OR?: PositionWhereInput[]
    NOT?: PositionWhereInput | PositionWhereInput[]
    id?: StringFilter<"Position"> | string
    name?: StringFilter<"Position"> | string
    users?: UserListRelationFilter
    companies?: CompanyListRelationFilter
    electedMembers?: ElectedMemberListRelationFilter
  }

  export type PositionOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    users?: UserOrderByRelationAggregateInput
    companies?: CompanyOrderByRelationAggregateInput
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
  }

  export type PositionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PositionWhereInput | PositionWhereInput[]
    OR?: PositionWhereInput[]
    NOT?: PositionWhereInput | PositionWhereInput[]
    name?: StringFilter<"Position"> | string
    users?: UserListRelationFilter
    companies?: CompanyListRelationFilter
    electedMembers?: ElectedMemberListRelationFilter
  }, "id">

  export type PositionOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: PositionCountOrderByAggregateInput
    _max?: PositionMaxOrderByAggregateInput
    _min?: PositionMinOrderByAggregateInput
  }

  export type PositionScalarWhereWithAggregatesInput = {
    AND?: PositionScalarWhereWithAggregatesInput | PositionScalarWhereWithAggregatesInput[]
    OR?: PositionScalarWhereWithAggregatesInput[]
    NOT?: PositionScalarWhereWithAggregatesInput | PositionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Position"> | string
    name?: StringWithAggregatesFilter<"Position"> | string
  }

  export type ActivityFamilyWhereInput = {
    AND?: ActivityFamilyWhereInput | ActivityFamilyWhereInput[]
    OR?: ActivityFamilyWhereInput[]
    NOT?: ActivityFamilyWhereInput | ActivityFamilyWhereInput[]
    id?: StringFilter<"ActivityFamily"> | string
    name?: StringFilter<"ActivityFamily"> | string
    activities?: ActivityListRelationFilter
    electedMembers?: ElectedMemberListRelationFilter
  }

  export type ActivityFamilyOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    activities?: ActivityOrderByRelationAggregateInput
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
  }

  export type ActivityFamilyWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ActivityFamilyWhereInput | ActivityFamilyWhereInput[]
    OR?: ActivityFamilyWhereInput[]
    NOT?: ActivityFamilyWhereInput | ActivityFamilyWhereInput[]
    name?: StringFilter<"ActivityFamily"> | string
    activities?: ActivityListRelationFilter
    electedMembers?: ElectedMemberListRelationFilter
  }, "id">

  export type ActivityFamilyOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: ActivityFamilyCountOrderByAggregateInput
    _max?: ActivityFamilyMaxOrderByAggregateInput
    _min?: ActivityFamilyMinOrderByAggregateInput
  }

  export type ActivityFamilyScalarWhereWithAggregatesInput = {
    AND?: ActivityFamilyScalarWhereWithAggregatesInput | ActivityFamilyScalarWhereWithAggregatesInput[]
    OR?: ActivityFamilyScalarWhereWithAggregatesInput[]
    NOT?: ActivityFamilyScalarWhereWithAggregatesInput | ActivityFamilyScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ActivityFamily"> | string
    name?: StringWithAggregatesFilter<"ActivityFamily"> | string
  }

  export type ActivityWhereInput = {
    AND?: ActivityWhereInput | ActivityWhereInput[]
    OR?: ActivityWhereInput[]
    NOT?: ActivityWhereInput | ActivityWhereInput[]
    id?: StringFilter<"Activity"> | string
    name?: StringFilter<"Activity"> | string
    activityFamilyId?: StringFilter<"Activity"> | string
    activityFamily?: XOR<ActivityFamilyRelationFilter, ActivityFamilyWhereInput>
    electedMembers?: ElectedMemberListRelationFilter
  }

  export type ActivityOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    activityFamilyId?: SortOrder
    activityFamily?: ActivityFamilyOrderByWithRelationInput
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
  }

  export type ActivityWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ActivityWhereInput | ActivityWhereInput[]
    OR?: ActivityWhereInput[]
    NOT?: ActivityWhereInput | ActivityWhereInput[]
    name?: StringFilter<"Activity"> | string
    activityFamilyId?: StringFilter<"Activity"> | string
    activityFamily?: XOR<ActivityFamilyRelationFilter, ActivityFamilyWhereInput>
    electedMembers?: ElectedMemberListRelationFilter
  }, "id">

  export type ActivityOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    activityFamilyId?: SortOrder
    _count?: ActivityCountOrderByAggregateInput
    _max?: ActivityMaxOrderByAggregateInput
    _min?: ActivityMinOrderByAggregateInput
  }

  export type ActivityScalarWhereWithAggregatesInput = {
    AND?: ActivityScalarWhereWithAggregatesInput | ActivityScalarWhereWithAggregatesInput[]
    OR?: ActivityScalarWhereWithAggregatesInput[]
    NOT?: ActivityScalarWhereWithAggregatesInput | ActivityScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Activity"> | string
    name?: StringWithAggregatesFilter<"Activity"> | string
    activityFamilyId?: StringWithAggregatesFilter<"Activity"> | string
  }

  export type ExpertiseAreaWhereInput = {
    AND?: ExpertiseAreaWhereInput | ExpertiseAreaWhereInput[]
    OR?: ExpertiseAreaWhereInput[]
    NOT?: ExpertiseAreaWhereInput | ExpertiseAreaWhereInput[]
    id?: StringFilter<"ExpertiseArea"> | string
    name?: StringFilter<"ExpertiseArea"> | string
  }

  export type ExpertiseAreaOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ExpertiseAreaWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ExpertiseAreaWhereInput | ExpertiseAreaWhereInput[]
    OR?: ExpertiseAreaWhereInput[]
    NOT?: ExpertiseAreaWhereInput | ExpertiseAreaWhereInput[]
    name?: StringFilter<"ExpertiseArea"> | string
  }, "id">

  export type ExpertiseAreaOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: ExpertiseAreaCountOrderByAggregateInput
    _max?: ExpertiseAreaMaxOrderByAggregateInput
    _min?: ExpertiseAreaMinOrderByAggregateInput
  }

  export type ExpertiseAreaScalarWhereWithAggregatesInput = {
    AND?: ExpertiseAreaScalarWhereWithAggregatesInput | ExpertiseAreaScalarWhereWithAggregatesInput[]
    OR?: ExpertiseAreaScalarWhereWithAggregatesInput[]
    NOT?: ExpertiseAreaScalarWhereWithAggregatesInput | ExpertiseAreaScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ExpertiseArea"> | string
    name?: StringWithAggregatesFilter<"ExpertiseArea"> | string
  }

  export type InterestAreaWhereInput = {
    AND?: InterestAreaWhereInput | InterestAreaWhereInput[]
    OR?: InterestAreaWhereInput[]
    NOT?: InterestAreaWhereInput | InterestAreaWhereInput[]
    id?: StringFilter<"InterestArea"> | string
    name?: StringFilter<"InterestArea"> | string
  }

  export type InterestAreaOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type InterestAreaWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: InterestAreaWhereInput | InterestAreaWhereInput[]
    OR?: InterestAreaWhereInput[]
    NOT?: InterestAreaWhereInput | InterestAreaWhereInput[]
    name?: StringFilter<"InterestArea"> | string
  }, "id">

  export type InterestAreaOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: InterestAreaCountOrderByAggregateInput
    _max?: InterestAreaMaxOrderByAggregateInput
    _min?: InterestAreaMinOrderByAggregateInput
  }

  export type InterestAreaScalarWhereWithAggregatesInput = {
    AND?: InterestAreaScalarWhereWithAggregatesInput | InterestAreaScalarWhereWithAggregatesInput[]
    OR?: InterestAreaScalarWhereWithAggregatesInput[]
    NOT?: InterestAreaScalarWhereWithAggregatesInput | InterestAreaScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"InterestArea"> | string
    name?: StringWithAggregatesFilter<"InterestArea"> | string
  }

  export type ProvinceWhereInput = {
    AND?: ProvinceWhereInput | ProvinceWhereInput[]
    OR?: ProvinceWhereInput[]
    NOT?: ProvinceWhereInput | ProvinceWhereInput[]
    id?: StringFilter<"Province"> | string
    name?: StringFilter<"Province"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }

  export type ProvinceOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
    user?: UserOrderByRelationAggregateInput
  }

  export type ProvinceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProvinceWhereInput | ProvinceWhereInput[]
    OR?: ProvinceWhereInput[]
    NOT?: ProvinceWhereInput | ProvinceWhereInput[]
    name?: StringFilter<"Province"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }, "id">

  export type ProvinceOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: ProvinceCountOrderByAggregateInput
    _max?: ProvinceMaxOrderByAggregateInput
    _min?: ProvinceMinOrderByAggregateInput
  }

  export type ProvinceScalarWhereWithAggregatesInput = {
    AND?: ProvinceScalarWhereWithAggregatesInput | ProvinceScalarWhereWithAggregatesInput[]
    OR?: ProvinceScalarWhereWithAggregatesInput[]
    NOT?: ProvinceScalarWhereWithAggregatesInput | ProvinceScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Province"> | string
    name?: StringWithAggregatesFilter<"Province"> | string
  }

  export type CategoryWhereInput = {
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    id?: StringFilter<"Category"> | string
    name?: StringFilter<"Category"> | string
    nameAr?: StringFilter<"Category"> | string
    editions?: EditionListRelationFilter
  }

  export type CategoryOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    nameAr?: SortOrder
    editions?: EditionOrderByRelationAggregateInput
  }

  export type CategoryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    name?: StringFilter<"Category"> | string
    nameAr?: StringFilter<"Category"> | string
    editions?: EditionListRelationFilter
  }, "id">

  export type CategoryOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    nameAr?: SortOrder
    _count?: CategoryCountOrderByAggregateInput
    _max?: CategoryMaxOrderByAggregateInput
    _min?: CategoryMinOrderByAggregateInput
  }

  export type CategoryScalarWhereWithAggregatesInput = {
    AND?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    OR?: CategoryScalarWhereWithAggregatesInput[]
    NOT?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Category"> | string
    name?: StringWithAggregatesFilter<"Category"> | string
    nameAr?: StringWithAggregatesFilter<"Category"> | string
  }

  export type CommissionWhereInput = {
    AND?: CommissionWhereInput | CommissionWhereInput[]
    OR?: CommissionWhereInput[]
    NOT?: CommissionWhereInput | CommissionWhereInput[]
    id?: StringFilter<"Commission"> | string
    name?: StringFilter<"Commission"> | string
    description?: StringFilter<"Commission"> | string
  }

  export type CommissionOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
  }

  export type CommissionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CommissionWhereInput | CommissionWhereInput[]
    OR?: CommissionWhereInput[]
    NOT?: CommissionWhereInput | CommissionWhereInput[]
    name?: StringFilter<"Commission"> | string
    description?: StringFilter<"Commission"> | string
  }, "id">

  export type CommissionOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    _count?: CommissionCountOrderByAggregateInput
    _max?: CommissionMaxOrderByAggregateInput
    _min?: CommissionMinOrderByAggregateInput
  }

  export type CommissionScalarWhereWithAggregatesInput = {
    AND?: CommissionScalarWhereWithAggregatesInput | CommissionScalarWhereWithAggregatesInput[]
    OR?: CommissionScalarWhereWithAggregatesInput[]
    NOT?: CommissionScalarWhereWithAggregatesInput | CommissionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Commission"> | string
    name?: StringWithAggregatesFilter<"Commission"> | string
    description?: StringWithAggregatesFilter<"Commission"> | string
  }

  export type MandateWhereInput = {
    AND?: MandateWhereInput | MandateWhereInput[]
    OR?: MandateWhereInput[]
    NOT?: MandateWhereInput | MandateWhereInput[]
    id?: StringFilter<"Mandate"> | string
    name?: StringFilter<"Mandate"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }

  export type MandateOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
    user?: UserOrderByRelationAggregateInput
  }

  export type MandateWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MandateWhereInput | MandateWhereInput[]
    OR?: MandateWhereInput[]
    NOT?: MandateWhereInput | MandateWhereInput[]
    name?: StringFilter<"Mandate"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }, "id">

  export type MandateOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: MandateCountOrderByAggregateInput
    _max?: MandateMaxOrderByAggregateInput
    _min?: MandateMinOrderByAggregateInput
  }

  export type MandateScalarWhereWithAggregatesInput = {
    AND?: MandateScalarWhereWithAggregatesInput | MandateScalarWhereWithAggregatesInput[]
    OR?: MandateScalarWhereWithAggregatesInput[]
    NOT?: MandateScalarWhereWithAggregatesInput | MandateScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Mandate"> | string
    name?: StringWithAggregatesFilter<"Mandate"> | string
  }

  export type CollegeWhereInput = {
    AND?: CollegeWhereInput | CollegeWhereInput[]
    OR?: CollegeWhereInput[]
    NOT?: CollegeWhereInput | CollegeWhereInput[]
    id?: StringFilter<"College"> | string
    name?: StringFilter<"College"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }

  export type CollegeOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    electedMembers?: ElectedMemberOrderByRelationAggregateInput
    user?: UserOrderByRelationAggregateInput
  }

  export type CollegeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CollegeWhereInput | CollegeWhereInput[]
    OR?: CollegeWhereInput[]
    NOT?: CollegeWhereInput | CollegeWhereInput[]
    name?: StringFilter<"College"> | string
    electedMembers?: ElectedMemberListRelationFilter
    user?: UserListRelationFilter
  }, "id">

  export type CollegeOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: CollegeCountOrderByAggregateInput
    _max?: CollegeMaxOrderByAggregateInput
    _min?: CollegeMinOrderByAggregateInput
  }

  export type CollegeScalarWhereWithAggregatesInput = {
    AND?: CollegeScalarWhereWithAggregatesInput | CollegeScalarWhereWithAggregatesInput[]
    OR?: CollegeScalarWhereWithAggregatesInput[]
    NOT?: CollegeScalarWhereWithAggregatesInput | CollegeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"College"> | string
    name?: StringWithAggregatesFilter<"College"> | string
  }

  export type ElectedMemberWhereInput = {
    AND?: ElectedMemberWhereInput | ElectedMemberWhereInput[]
    OR?: ElectedMemberWhereInput[]
    NOT?: ElectedMemberWhereInput | ElectedMemberWhereInput[]
    id?: StringFilter<"ElectedMember"> | string
    image?: StringNullableFilter<"ElectedMember"> | string | null
    fullName?: StringFilter<"ElectedMember"> | string
    positionId?: StringFilter<"ElectedMember"> | string
    activityFamilyId?: StringFilter<"ElectedMember"> | string
    activityId?: StringFilter<"ElectedMember"> | string
    phoneNumber?: StringFilter<"ElectedMember"> | string
    gsm?: StringFilter<"ElectedMember"> | string
    fax?: StringFilter<"ElectedMember"> | string
    email?: StringFilter<"ElectedMember"> | string
    adresse?: StringFilter<"ElectedMember"> | string
    collegeId?: StringFilter<"ElectedMember"> | string
    provinceId?: StringFilter<"ElectedMember"> | string
    mandateId?: StringFilter<"ElectedMember"> | string
    commissions?: StringNullableListFilter<"ElectedMember">
    details?: StringFilter<"ElectedMember"> | string
    position?: XOR<PositionRelationFilter, PositionWhereInput>
    activityFamily?: XOR<ActivityFamilyRelationFilter, ActivityFamilyWhereInput>
    activity?: XOR<ActivityRelationFilter, ActivityWhereInput>
    college?: XOR<CollegeRelationFilter, CollegeWhereInput>
    province?: XOR<ProvinceRelationFilter, ProvinceWhereInput>
    mandate?: XOR<MandateRelationFilter, MandateWhereInput>
  }

  export type ElectedMemberOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    fullName?: SortOrder
    positionId?: SortOrder
    activityFamilyId?: SortOrder
    activityId?: SortOrder
    phoneNumber?: SortOrder
    gsm?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    commissions?: SortOrder
    details?: SortOrder
    position?: PositionOrderByWithRelationInput
    activityFamily?: ActivityFamilyOrderByWithRelationInput
    activity?: ActivityOrderByWithRelationInput
    college?: CollegeOrderByWithRelationInput
    province?: ProvinceOrderByWithRelationInput
    mandate?: MandateOrderByWithRelationInput
  }

  export type ElectedMemberWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ElectedMemberWhereInput | ElectedMemberWhereInput[]
    OR?: ElectedMemberWhereInput[]
    NOT?: ElectedMemberWhereInput | ElectedMemberWhereInput[]
    image?: StringNullableFilter<"ElectedMember"> | string | null
    fullName?: StringFilter<"ElectedMember"> | string
    positionId?: StringFilter<"ElectedMember"> | string
    activityFamilyId?: StringFilter<"ElectedMember"> | string
    activityId?: StringFilter<"ElectedMember"> | string
    phoneNumber?: StringFilter<"ElectedMember"> | string
    gsm?: StringFilter<"ElectedMember"> | string
    fax?: StringFilter<"ElectedMember"> | string
    email?: StringFilter<"ElectedMember"> | string
    adresse?: StringFilter<"ElectedMember"> | string
    collegeId?: StringFilter<"ElectedMember"> | string
    provinceId?: StringFilter<"ElectedMember"> | string
    mandateId?: StringFilter<"ElectedMember"> | string
    commissions?: StringNullableListFilter<"ElectedMember">
    details?: StringFilter<"ElectedMember"> | string
    position?: XOR<PositionRelationFilter, PositionWhereInput>
    activityFamily?: XOR<ActivityFamilyRelationFilter, ActivityFamilyWhereInput>
    activity?: XOR<ActivityRelationFilter, ActivityWhereInput>
    college?: XOR<CollegeRelationFilter, CollegeWhereInput>
    province?: XOR<ProvinceRelationFilter, ProvinceWhereInput>
    mandate?: XOR<MandateRelationFilter, MandateWhereInput>
  }, "id">

  export type ElectedMemberOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    fullName?: SortOrder
    positionId?: SortOrder
    activityFamilyId?: SortOrder
    activityId?: SortOrder
    phoneNumber?: SortOrder
    gsm?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    commissions?: SortOrder
    details?: SortOrder
    _count?: ElectedMemberCountOrderByAggregateInput
    _max?: ElectedMemberMaxOrderByAggregateInput
    _min?: ElectedMemberMinOrderByAggregateInput
  }

  export type ElectedMemberScalarWhereWithAggregatesInput = {
    AND?: ElectedMemberScalarWhereWithAggregatesInput | ElectedMemberScalarWhereWithAggregatesInput[]
    OR?: ElectedMemberScalarWhereWithAggregatesInput[]
    NOT?: ElectedMemberScalarWhereWithAggregatesInput | ElectedMemberScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ElectedMember"> | string
    image?: StringNullableWithAggregatesFilter<"ElectedMember"> | string | null
    fullName?: StringWithAggregatesFilter<"ElectedMember"> | string
    positionId?: StringWithAggregatesFilter<"ElectedMember"> | string
    activityFamilyId?: StringWithAggregatesFilter<"ElectedMember"> | string
    activityId?: StringWithAggregatesFilter<"ElectedMember"> | string
    phoneNumber?: StringWithAggregatesFilter<"ElectedMember"> | string
    gsm?: StringWithAggregatesFilter<"ElectedMember"> | string
    fax?: StringWithAggregatesFilter<"ElectedMember"> | string
    email?: StringWithAggregatesFilter<"ElectedMember"> | string
    adresse?: StringWithAggregatesFilter<"ElectedMember"> | string
    collegeId?: StringWithAggregatesFilter<"ElectedMember"> | string
    provinceId?: StringWithAggregatesFilter<"ElectedMember"> | string
    mandateId?: StringWithAggregatesFilter<"ElectedMember"> | string
    commissions?: StringNullableListFilter<"ElectedMember">
    details?: StringWithAggregatesFilter<"ElectedMember"> | string
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    civility?: EnumCivilityFilter<"User"> | $Enums.Civility
    firstName?: StringFilter<"User"> | string
    lastName?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    cityId?: StringNullableFilter<"User"> | string | null
    positionId?: StringNullableFilter<"User"> | string | null
    phoneNumber?: StringFilter<"User"> | string
    expertiseAreas?: StringNullableListFilter<"User">
    interestAreas?: StringNullableListFilter<"User">
    bio?: StringFilter<"User"> | string
    companyId?: StringNullableFilter<"User"> | string | null
    department?: StringNullableFilter<"User"> | string | null
    service?: StringNullableFilter<"User"> | string | null
    adresse?: StringNullableFilter<"User"> | string | null
    collegeId?: StringNullableFilter<"User"> | string | null
    provinceId?: StringNullableFilter<"User"> | string | null
    mandateId?: StringNullableFilter<"User"> | string | null
    commissions?: StringNullableListFilter<"User">
    details?: StringNullableFilter<"User"> | string | null
    active?: BoolFilter<"User"> | boolean
    member?: BoolFilter<"User"> | boolean
    role?: EnumRoleFilter<"User"> | $Enums.Role
    permissions?: EnumPermissionNullableListFilter<"User">
    resetPasswordCode?: StringNullableFilter<"User"> | string | null
    resetPasswordAt?: DateTimeNullableFilter<"User"> | Date | string | null
    loggedInAt?: DateTimeNullableFilter<"User"> | Date | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    position?: XOR<PositionNullableRelationFilter, PositionWhereInput> | null
    company?: XOR<CompanyNullableRelationFilter, CompanyWhereInput> | null
    college?: XOR<CollegeNullableRelationFilter, CollegeWhereInput> | null
    province?: XOR<ProvinceNullableRelationFilter, ProvinceWhereInput> | null
    mandate?: XOR<MandateNullableRelationFilter, MandateWhereInput> | null
    connectionsSent?: ConnectionListRelationFilter
    connectionsReceived?: ConnectionListRelationFilter
    messagesSent?: MessageListRelationFilter
    messagesReceived?: MessageListRelationFilter
    opportunities?: OpportunityListRelationFilter
    opportunityLikes?: OpportunityLikeListRelationFilter
    opportunityComments?: OpportunityCommentListRelationFilter
    eventLikes?: EventLikeListRelationFilter
    eventComments?: EventCommentListRelationFilter
    appointmentLikes?: AppointmentLikeListRelationFilter
    appointmentComments?: AppointmentCommentListRelationFilter
    notifications?: NotificationListRelationFilter
    appointmentsRegistrations?: AppointmentRegistrationListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    civility?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    password?: SortOrder
    cityId?: SortOrderInput | SortOrder
    positionId?: SortOrderInput | SortOrder
    phoneNumber?: SortOrder
    expertiseAreas?: SortOrder
    interestAreas?: SortOrder
    bio?: SortOrder
    companyId?: SortOrderInput | SortOrder
    department?: SortOrderInput | SortOrder
    service?: SortOrderInput | SortOrder
    adresse?: SortOrderInput | SortOrder
    collegeId?: SortOrderInput | SortOrder
    provinceId?: SortOrderInput | SortOrder
    mandateId?: SortOrderInput | SortOrder
    commissions?: SortOrder
    details?: SortOrderInput | SortOrder
    active?: SortOrder
    member?: SortOrder
    role?: SortOrder
    permissions?: SortOrder
    resetPasswordCode?: SortOrderInput | SortOrder
    resetPasswordAt?: SortOrderInput | SortOrder
    loggedInAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    city?: CityOrderByWithRelationInput
    position?: PositionOrderByWithRelationInput
    company?: CompanyOrderByWithRelationInput
    college?: CollegeOrderByWithRelationInput
    province?: ProvinceOrderByWithRelationInput
    mandate?: MandateOrderByWithRelationInput
    connectionsSent?: ConnectionOrderByRelationAggregateInput
    connectionsReceived?: ConnectionOrderByRelationAggregateInput
    messagesSent?: MessageOrderByRelationAggregateInput
    messagesReceived?: MessageOrderByRelationAggregateInput
    opportunities?: OpportunityOrderByRelationAggregateInput
    opportunityLikes?: OpportunityLikeOrderByRelationAggregateInput
    opportunityComments?: OpportunityCommentOrderByRelationAggregateInput
    eventLikes?: EventLikeOrderByRelationAggregateInput
    eventComments?: EventCommentOrderByRelationAggregateInput
    appointmentLikes?: AppointmentLikeOrderByRelationAggregateInput
    appointmentComments?: AppointmentCommentOrderByRelationAggregateInput
    notifications?: NotificationOrderByRelationAggregateInput
    appointmentsRegistrations?: AppointmentRegistrationOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    civility?: EnumCivilityFilter<"User"> | $Enums.Civility
    firstName?: StringFilter<"User"> | string
    lastName?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    cityId?: StringNullableFilter<"User"> | string | null
    positionId?: StringNullableFilter<"User"> | string | null
    phoneNumber?: StringFilter<"User"> | string
    expertiseAreas?: StringNullableListFilter<"User">
    interestAreas?: StringNullableListFilter<"User">
    bio?: StringFilter<"User"> | string
    companyId?: StringNullableFilter<"User"> | string | null
    department?: StringNullableFilter<"User"> | string | null
    service?: StringNullableFilter<"User"> | string | null
    adresse?: StringNullableFilter<"User"> | string | null
    collegeId?: StringNullableFilter<"User"> | string | null
    provinceId?: StringNullableFilter<"User"> | string | null
    mandateId?: StringNullableFilter<"User"> | string | null
    commissions?: StringNullableListFilter<"User">
    details?: StringNullableFilter<"User"> | string | null
    active?: BoolFilter<"User"> | boolean
    member?: BoolFilter<"User"> | boolean
    role?: EnumRoleFilter<"User"> | $Enums.Role
    permissions?: EnumPermissionNullableListFilter<"User">
    resetPasswordCode?: StringNullableFilter<"User"> | string | null
    resetPasswordAt?: DateTimeNullableFilter<"User"> | Date | string | null
    loggedInAt?: DateTimeNullableFilter<"User"> | Date | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    position?: XOR<PositionNullableRelationFilter, PositionWhereInput> | null
    company?: XOR<CompanyNullableRelationFilter, CompanyWhereInput> | null
    college?: XOR<CollegeNullableRelationFilter, CollegeWhereInput> | null
    province?: XOR<ProvinceNullableRelationFilter, ProvinceWhereInput> | null
    mandate?: XOR<MandateNullableRelationFilter, MandateWhereInput> | null
    connectionsSent?: ConnectionListRelationFilter
    connectionsReceived?: ConnectionListRelationFilter
    messagesSent?: MessageListRelationFilter
    messagesReceived?: MessageListRelationFilter
    opportunities?: OpportunityListRelationFilter
    opportunityLikes?: OpportunityLikeListRelationFilter
    opportunityComments?: OpportunityCommentListRelationFilter
    eventLikes?: EventLikeListRelationFilter
    eventComments?: EventCommentListRelationFilter
    appointmentLikes?: AppointmentLikeListRelationFilter
    appointmentComments?: AppointmentCommentListRelationFilter
    notifications?: NotificationListRelationFilter
    appointmentsRegistrations?: AppointmentRegistrationListRelationFilter
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    civility?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    password?: SortOrder
    cityId?: SortOrderInput | SortOrder
    positionId?: SortOrderInput | SortOrder
    phoneNumber?: SortOrder
    expertiseAreas?: SortOrder
    interestAreas?: SortOrder
    bio?: SortOrder
    companyId?: SortOrderInput | SortOrder
    department?: SortOrderInput | SortOrder
    service?: SortOrderInput | SortOrder
    adresse?: SortOrderInput | SortOrder
    collegeId?: SortOrderInput | SortOrder
    provinceId?: SortOrderInput | SortOrder
    mandateId?: SortOrderInput | SortOrder
    commissions?: SortOrder
    details?: SortOrderInput | SortOrder
    active?: SortOrder
    member?: SortOrder
    role?: SortOrder
    permissions?: SortOrder
    resetPasswordCode?: SortOrderInput | SortOrder
    resetPasswordAt?: SortOrderInput | SortOrder
    loggedInAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    civility?: EnumCivilityWithAggregatesFilter<"User"> | $Enums.Civility
    firstName?: StringWithAggregatesFilter<"User"> | string
    lastName?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    password?: StringWithAggregatesFilter<"User"> | string
    cityId?: StringNullableWithAggregatesFilter<"User"> | string | null
    positionId?: StringNullableWithAggregatesFilter<"User"> | string | null
    phoneNumber?: StringWithAggregatesFilter<"User"> | string
    expertiseAreas?: StringNullableListFilter<"User">
    interestAreas?: StringNullableListFilter<"User">
    bio?: StringWithAggregatesFilter<"User"> | string
    companyId?: StringNullableWithAggregatesFilter<"User"> | string | null
    department?: StringNullableWithAggregatesFilter<"User"> | string | null
    service?: StringNullableWithAggregatesFilter<"User"> | string | null
    adresse?: StringNullableWithAggregatesFilter<"User"> | string | null
    collegeId?: StringNullableWithAggregatesFilter<"User"> | string | null
    provinceId?: StringNullableWithAggregatesFilter<"User"> | string | null
    mandateId?: StringNullableWithAggregatesFilter<"User"> | string | null
    commissions?: StringNullableListFilter<"User">
    details?: StringNullableWithAggregatesFilter<"User"> | string | null
    active?: BoolWithAggregatesFilter<"User"> | boolean
    member?: BoolWithAggregatesFilter<"User"> | boolean
    role?: EnumRoleWithAggregatesFilter<"User"> | $Enums.Role
    permissions?: EnumPermissionNullableListFilter<"User">
    resetPasswordCode?: StringNullableWithAggregatesFilter<"User"> | string | null
    resetPasswordAt?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    loggedInAt?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type NotificationWhereInput = {
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    id?: StringFilter<"Notification"> | string
    title?: StringFilter<"Notification"> | string
    content?: StringFilter<"Notification"> | string
    source?: EnumSourceFilter<"Notification"> | $Enums.Source
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    isRead?: BoolFilter<"Notification"> | boolean
    userId?: StringFilter<"Notification"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type NotificationOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    content?: SortOrder
    source?: SortOrder
    createdAt?: SortOrder
    isRead?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type NotificationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    title?: StringFilter<"Notification"> | string
    content?: StringFilter<"Notification"> | string
    source?: EnumSourceFilter<"Notification"> | $Enums.Source
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    isRead?: BoolFilter<"Notification"> | boolean
    userId?: StringFilter<"Notification"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type NotificationOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    content?: SortOrder
    source?: SortOrder
    createdAt?: SortOrder
    isRead?: SortOrder
    userId?: SortOrder
    _count?: NotificationCountOrderByAggregateInput
    _max?: NotificationMaxOrderByAggregateInput
    _min?: NotificationMinOrderByAggregateInput
  }

  export type NotificationScalarWhereWithAggregatesInput = {
    AND?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    OR?: NotificationScalarWhereWithAggregatesInput[]
    NOT?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Notification"> | string
    title?: StringWithAggregatesFilter<"Notification"> | string
    content?: StringWithAggregatesFilter<"Notification"> | string
    source?: EnumSourceWithAggregatesFilter<"Notification"> | $Enums.Source
    createdAt?: DateTimeWithAggregatesFilter<"Notification"> | Date | string
    isRead?: BoolWithAggregatesFilter<"Notification"> | boolean
    userId?: StringWithAggregatesFilter<"Notification"> | string
  }

  export type CompanyWhereInput = {
    AND?: CompanyWhereInput | CompanyWhereInput[]
    OR?: CompanyWhereInput[]
    NOT?: CompanyWhereInput | CompanyWhereInput[]
    id?: StringFilter<"Company"> | string
    logo?: StringNullableFilter<"Company"> | string | null
    name?: StringFilter<"Company"> | string
    legalForm?: EnumLegalFormFilter<"Company"> | $Enums.LegalForm
    cityId?: StringNullableFilter<"Company"> | string | null
    address?: StringFilter<"Company"> | string
    phoneNumber?: StringFilter<"Company"> | string
    fax?: StringFilter<"Company"> | string
    email?: StringFilter<"Company"> | string
    website?: StringFilter<"Company"> | string
    linkedin?: StringFilter<"Company"> | string
    facebook?: StringFilter<"Company"> | string
    contactFirstName?: StringFilter<"Company"> | string
    contactLastName?: StringFilter<"Company"> | string
    contactEmail?: StringFilter<"Company"> | string
    contactPositionId?: StringNullableFilter<"Company"> | string | null
    contactLinkedin?: StringFilter<"Company"> | string
    contactFacebook?: StringFilter<"Company"> | string
    businessLicense?: StringFilter<"Company"> | string
    numRC?: StringFilter<"Company"> | string
    numICE?: StringFilter<"Company"> | string
    capital?: FloatNullableFilter<"Company"> | number | null
    turnoverId?: StringNullableFilter<"Company"> | string | null
    nEmployeesId?: StringNullableFilter<"Company"> | string | null
    activitiesFamilies?: StringNullableListFilter<"Company">
    activities?: StringNullableListFilter<"Company">
    importCountries?: StringNullableListFilter<"Company">
    exportCountries?: StringNullableListFilter<"Company">
    verified?: BoolFilter<"Company"> | boolean
    active?: BoolFilter<"Company"> | boolean
    partner?: BoolFilter<"Company"> | boolean
    contributor?: BoolFilter<"Company"> | boolean
    createdAt?: DateTimeFilter<"Company"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    contactPosition?: XOR<PositionNullableRelationFilter, PositionWhereInput> | null
    turnover?: XOR<TurnoverNullableRelationFilter, TurnoverWhereInput> | null
    nEmployees?: XOR<NEmployeesNullableRelationFilter, NEmployeesWhereInput> | null
    users?: UserListRelationFilter
  }

  export type CompanyOrderByWithRelationInput = {
    id?: SortOrder
    logo?: SortOrderInput | SortOrder
    name?: SortOrder
    legalForm?: SortOrder
    cityId?: SortOrderInput | SortOrder
    address?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    linkedin?: SortOrder
    facebook?: SortOrder
    contactFirstName?: SortOrder
    contactLastName?: SortOrder
    contactEmail?: SortOrder
    contactPositionId?: SortOrderInput | SortOrder
    contactLinkedin?: SortOrder
    contactFacebook?: SortOrder
    businessLicense?: SortOrder
    numRC?: SortOrder
    numICE?: SortOrder
    capital?: SortOrderInput | SortOrder
    turnoverId?: SortOrderInput | SortOrder
    nEmployeesId?: SortOrderInput | SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    importCountries?: SortOrder
    exportCountries?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    partner?: SortOrder
    contributor?: SortOrder
    createdAt?: SortOrder
    city?: CityOrderByWithRelationInput
    contactPosition?: PositionOrderByWithRelationInput
    turnover?: TurnoverOrderByWithRelationInput
    nEmployees?: NEmployeesOrderByWithRelationInput
    users?: UserOrderByRelationAggregateInput
  }

  export type CompanyWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CompanyWhereInput | CompanyWhereInput[]
    OR?: CompanyWhereInput[]
    NOT?: CompanyWhereInput | CompanyWhereInput[]
    logo?: StringNullableFilter<"Company"> | string | null
    name?: StringFilter<"Company"> | string
    legalForm?: EnumLegalFormFilter<"Company"> | $Enums.LegalForm
    cityId?: StringNullableFilter<"Company"> | string | null
    address?: StringFilter<"Company"> | string
    phoneNumber?: StringFilter<"Company"> | string
    fax?: StringFilter<"Company"> | string
    email?: StringFilter<"Company"> | string
    website?: StringFilter<"Company"> | string
    linkedin?: StringFilter<"Company"> | string
    facebook?: StringFilter<"Company"> | string
    contactFirstName?: StringFilter<"Company"> | string
    contactLastName?: StringFilter<"Company"> | string
    contactEmail?: StringFilter<"Company"> | string
    contactPositionId?: StringNullableFilter<"Company"> | string | null
    contactLinkedin?: StringFilter<"Company"> | string
    contactFacebook?: StringFilter<"Company"> | string
    businessLicense?: StringFilter<"Company"> | string
    numRC?: StringFilter<"Company"> | string
    numICE?: StringFilter<"Company"> | string
    capital?: FloatNullableFilter<"Company"> | number | null
    turnoverId?: StringNullableFilter<"Company"> | string | null
    nEmployeesId?: StringNullableFilter<"Company"> | string | null
    activitiesFamilies?: StringNullableListFilter<"Company">
    activities?: StringNullableListFilter<"Company">
    importCountries?: StringNullableListFilter<"Company">
    exportCountries?: StringNullableListFilter<"Company">
    verified?: BoolFilter<"Company"> | boolean
    active?: BoolFilter<"Company"> | boolean
    partner?: BoolFilter<"Company"> | boolean
    contributor?: BoolFilter<"Company"> | boolean
    createdAt?: DateTimeFilter<"Company"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    contactPosition?: XOR<PositionNullableRelationFilter, PositionWhereInput> | null
    turnover?: XOR<TurnoverNullableRelationFilter, TurnoverWhereInput> | null
    nEmployees?: XOR<NEmployeesNullableRelationFilter, NEmployeesWhereInput> | null
    users?: UserListRelationFilter
  }, "id">

  export type CompanyOrderByWithAggregationInput = {
    id?: SortOrder
    logo?: SortOrderInput | SortOrder
    name?: SortOrder
    legalForm?: SortOrder
    cityId?: SortOrderInput | SortOrder
    address?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    linkedin?: SortOrder
    facebook?: SortOrder
    contactFirstName?: SortOrder
    contactLastName?: SortOrder
    contactEmail?: SortOrder
    contactPositionId?: SortOrderInput | SortOrder
    contactLinkedin?: SortOrder
    contactFacebook?: SortOrder
    businessLicense?: SortOrder
    numRC?: SortOrder
    numICE?: SortOrder
    capital?: SortOrderInput | SortOrder
    turnoverId?: SortOrderInput | SortOrder
    nEmployeesId?: SortOrderInput | SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    importCountries?: SortOrder
    exportCountries?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    partner?: SortOrder
    contributor?: SortOrder
    createdAt?: SortOrder
    _count?: CompanyCountOrderByAggregateInput
    _avg?: CompanyAvgOrderByAggregateInput
    _max?: CompanyMaxOrderByAggregateInput
    _min?: CompanyMinOrderByAggregateInput
    _sum?: CompanySumOrderByAggregateInput
  }

  export type CompanyScalarWhereWithAggregatesInput = {
    AND?: CompanyScalarWhereWithAggregatesInput | CompanyScalarWhereWithAggregatesInput[]
    OR?: CompanyScalarWhereWithAggregatesInput[]
    NOT?: CompanyScalarWhereWithAggregatesInput | CompanyScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Company"> | string
    logo?: StringNullableWithAggregatesFilter<"Company"> | string | null
    name?: StringWithAggregatesFilter<"Company"> | string
    legalForm?: EnumLegalFormWithAggregatesFilter<"Company"> | $Enums.LegalForm
    cityId?: StringNullableWithAggregatesFilter<"Company"> | string | null
    address?: StringWithAggregatesFilter<"Company"> | string
    phoneNumber?: StringWithAggregatesFilter<"Company"> | string
    fax?: StringWithAggregatesFilter<"Company"> | string
    email?: StringWithAggregatesFilter<"Company"> | string
    website?: StringWithAggregatesFilter<"Company"> | string
    linkedin?: StringWithAggregatesFilter<"Company"> | string
    facebook?: StringWithAggregatesFilter<"Company"> | string
    contactFirstName?: StringWithAggregatesFilter<"Company"> | string
    contactLastName?: StringWithAggregatesFilter<"Company"> | string
    contactEmail?: StringWithAggregatesFilter<"Company"> | string
    contactPositionId?: StringNullableWithAggregatesFilter<"Company"> | string | null
    contactLinkedin?: StringWithAggregatesFilter<"Company"> | string
    contactFacebook?: StringWithAggregatesFilter<"Company"> | string
    businessLicense?: StringWithAggregatesFilter<"Company"> | string
    numRC?: StringWithAggregatesFilter<"Company"> | string
    numICE?: StringWithAggregatesFilter<"Company"> | string
    capital?: FloatNullableWithAggregatesFilter<"Company"> | number | null
    turnoverId?: StringNullableWithAggregatesFilter<"Company"> | string | null
    nEmployeesId?: StringNullableWithAggregatesFilter<"Company"> | string | null
    activitiesFamilies?: StringNullableListFilter<"Company">
    activities?: StringNullableListFilter<"Company">
    importCountries?: StringNullableListFilter<"Company">
    exportCountries?: StringNullableListFilter<"Company">
    verified?: BoolWithAggregatesFilter<"Company"> | boolean
    active?: BoolWithAggregatesFilter<"Company"> | boolean
    partner?: BoolWithAggregatesFilter<"Company"> | boolean
    contributor?: BoolWithAggregatesFilter<"Company"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Company"> | Date | string
  }

  export type ConnectionWhereInput = {
    AND?: ConnectionWhereInput | ConnectionWhereInput[]
    OR?: ConnectionWhereInput[]
    NOT?: ConnectionWhereInput | ConnectionWhereInput[]
    id?: StringFilter<"Connection"> | string
    senderId?: StringFilter<"Connection"> | string
    receiverId?: StringFilter<"Connection"> | string
    accepted?: BoolFilter<"Connection"> | boolean
    createdAt?: DateTimeFilter<"Connection"> | Date | string
    sender?: XOR<UserRelationFilter, UserWhereInput>
    receiver?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ConnectionOrderByWithRelationInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    accepted?: SortOrder
    createdAt?: SortOrder
    sender?: UserOrderByWithRelationInput
    receiver?: UserOrderByWithRelationInput
  }

  export type ConnectionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ConnectionWhereInput | ConnectionWhereInput[]
    OR?: ConnectionWhereInput[]
    NOT?: ConnectionWhereInput | ConnectionWhereInput[]
    senderId?: StringFilter<"Connection"> | string
    receiverId?: StringFilter<"Connection"> | string
    accepted?: BoolFilter<"Connection"> | boolean
    createdAt?: DateTimeFilter<"Connection"> | Date | string
    sender?: XOR<UserRelationFilter, UserWhereInput>
    receiver?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type ConnectionOrderByWithAggregationInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    accepted?: SortOrder
    createdAt?: SortOrder
    _count?: ConnectionCountOrderByAggregateInput
    _max?: ConnectionMaxOrderByAggregateInput
    _min?: ConnectionMinOrderByAggregateInput
  }

  export type ConnectionScalarWhereWithAggregatesInput = {
    AND?: ConnectionScalarWhereWithAggregatesInput | ConnectionScalarWhereWithAggregatesInput[]
    OR?: ConnectionScalarWhereWithAggregatesInput[]
    NOT?: ConnectionScalarWhereWithAggregatesInput | ConnectionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Connection"> | string
    senderId?: StringWithAggregatesFilter<"Connection"> | string
    receiverId?: StringWithAggregatesFilter<"Connection"> | string
    accepted?: BoolWithAggregatesFilter<"Connection"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Connection"> | Date | string
  }

  export type MessageWhereInput = {
    AND?: MessageWhereInput | MessageWhereInput[]
    OR?: MessageWhereInput[]
    NOT?: MessageWhereInput | MessageWhereInput[]
    id?: StringFilter<"Message"> | string
    senderId?: StringFilter<"Message"> | string
    receiverId?: StringFilter<"Message"> | string
    message?: StringFilter<"Message"> | string
    read?: BoolFilter<"Message"> | boolean
    createdAt?: DateTimeFilter<"Message"> | Date | string
    sender?: XOR<UserRelationFilter, UserWhereInput>
    receiver?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type MessageOrderByWithRelationInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    message?: SortOrder
    read?: SortOrder
    createdAt?: SortOrder
    sender?: UserOrderByWithRelationInput
    receiver?: UserOrderByWithRelationInput
  }

  export type MessageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MessageWhereInput | MessageWhereInput[]
    OR?: MessageWhereInput[]
    NOT?: MessageWhereInput | MessageWhereInput[]
    senderId?: StringFilter<"Message"> | string
    receiverId?: StringFilter<"Message"> | string
    message?: StringFilter<"Message"> | string
    read?: BoolFilter<"Message"> | boolean
    createdAt?: DateTimeFilter<"Message"> | Date | string
    sender?: XOR<UserRelationFilter, UserWhereInput>
    receiver?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type MessageOrderByWithAggregationInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    message?: SortOrder
    read?: SortOrder
    createdAt?: SortOrder
    _count?: MessageCountOrderByAggregateInput
    _max?: MessageMaxOrderByAggregateInput
    _min?: MessageMinOrderByAggregateInput
  }

  export type MessageScalarWhereWithAggregatesInput = {
    AND?: MessageScalarWhereWithAggregatesInput | MessageScalarWhereWithAggregatesInput[]
    OR?: MessageScalarWhereWithAggregatesInput[]
    NOT?: MessageScalarWhereWithAggregatesInput | MessageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Message"> | string
    senderId?: StringWithAggregatesFilter<"Message"> | string
    receiverId?: StringWithAggregatesFilter<"Message"> | string
    message?: StringWithAggregatesFilter<"Message"> | string
    read?: BoolWithAggregatesFilter<"Message"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Message"> | Date | string
  }

  export type OpportunityWhereInput = {
    AND?: OpportunityWhereInput | OpportunityWhereInput[]
    OR?: OpportunityWhereInput[]
    NOT?: OpportunityWhereInput | OpportunityWhereInput[]
    id?: StringFilter<"Opportunity"> | string
    title?: StringFilter<"Opportunity"> | string
    description?: StringFilter<"Opportunity"> | string
    companyName?: StringFilter<"Opportunity"> | string
    activitiesFamilies?: StringNullableListFilter<"Opportunity">
    activities?: StringNullableListFilter<"Opportunity">
    country?: StringFilter<"Opportunity"> | string
    address?: StringFilter<"Opportunity"> | string
    requirements?: StringFilter<"Opportunity"> | string
    contactEmail?: StringFilter<"Opportunity"> | string
    contactPhoneNumber?: StringFilter<"Opportunity"> | string
    creatorId?: StringFilter<"Opportunity"> | string
    document?: StringNullableFilter<"Opportunity"> | string | null
    verified?: BoolFilter<"Opportunity"> | boolean
    active?: BoolFilter<"Opportunity"> | boolean
    validityDate?: DateTimeNullableFilter<"Opportunity"> | Date | string | null
    createdAt?: DateTimeFilter<"Opportunity"> | Date | string
    creator?: XOR<UserRelationFilter, UserWhereInput>
    likes?: OpportunityLikeListRelationFilter
    comments?: OpportunityCommentListRelationFilter
  }

  export type OpportunityOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    companyName?: SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    country?: SortOrder
    address?: SortOrder
    requirements?: SortOrder
    contactEmail?: SortOrder
    contactPhoneNumber?: SortOrder
    creatorId?: SortOrder
    document?: SortOrderInput | SortOrder
    verified?: SortOrder
    active?: SortOrder
    validityDate?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    creator?: UserOrderByWithRelationInput
    likes?: OpportunityLikeOrderByRelationAggregateInput
    comments?: OpportunityCommentOrderByRelationAggregateInput
  }

  export type OpportunityWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OpportunityWhereInput | OpportunityWhereInput[]
    OR?: OpportunityWhereInput[]
    NOT?: OpportunityWhereInput | OpportunityWhereInput[]
    title?: StringFilter<"Opportunity"> | string
    description?: StringFilter<"Opportunity"> | string
    companyName?: StringFilter<"Opportunity"> | string
    activitiesFamilies?: StringNullableListFilter<"Opportunity">
    activities?: StringNullableListFilter<"Opportunity">
    country?: StringFilter<"Opportunity"> | string
    address?: StringFilter<"Opportunity"> | string
    requirements?: StringFilter<"Opportunity"> | string
    contactEmail?: StringFilter<"Opportunity"> | string
    contactPhoneNumber?: StringFilter<"Opportunity"> | string
    creatorId?: StringFilter<"Opportunity"> | string
    document?: StringNullableFilter<"Opportunity"> | string | null
    verified?: BoolFilter<"Opportunity"> | boolean
    active?: BoolFilter<"Opportunity"> | boolean
    validityDate?: DateTimeNullableFilter<"Opportunity"> | Date | string | null
    createdAt?: DateTimeFilter<"Opportunity"> | Date | string
    creator?: XOR<UserRelationFilter, UserWhereInput>
    likes?: OpportunityLikeListRelationFilter
    comments?: OpportunityCommentListRelationFilter
  }, "id">

  export type OpportunityOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    companyName?: SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    country?: SortOrder
    address?: SortOrder
    requirements?: SortOrder
    contactEmail?: SortOrder
    contactPhoneNumber?: SortOrder
    creatorId?: SortOrder
    document?: SortOrderInput | SortOrder
    verified?: SortOrder
    active?: SortOrder
    validityDate?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: OpportunityCountOrderByAggregateInput
    _max?: OpportunityMaxOrderByAggregateInput
    _min?: OpportunityMinOrderByAggregateInput
  }

  export type OpportunityScalarWhereWithAggregatesInput = {
    AND?: OpportunityScalarWhereWithAggregatesInput | OpportunityScalarWhereWithAggregatesInput[]
    OR?: OpportunityScalarWhereWithAggregatesInput[]
    NOT?: OpportunityScalarWhereWithAggregatesInput | OpportunityScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Opportunity"> | string
    title?: StringWithAggregatesFilter<"Opportunity"> | string
    description?: StringWithAggregatesFilter<"Opportunity"> | string
    companyName?: StringWithAggregatesFilter<"Opportunity"> | string
    activitiesFamilies?: StringNullableListFilter<"Opportunity">
    activities?: StringNullableListFilter<"Opportunity">
    country?: StringWithAggregatesFilter<"Opportunity"> | string
    address?: StringWithAggregatesFilter<"Opportunity"> | string
    requirements?: StringWithAggregatesFilter<"Opportunity"> | string
    contactEmail?: StringWithAggregatesFilter<"Opportunity"> | string
    contactPhoneNumber?: StringWithAggregatesFilter<"Opportunity"> | string
    creatorId?: StringWithAggregatesFilter<"Opportunity"> | string
    document?: StringNullableWithAggregatesFilter<"Opportunity"> | string | null
    verified?: BoolWithAggregatesFilter<"Opportunity"> | boolean
    active?: BoolWithAggregatesFilter<"Opportunity"> | boolean
    validityDate?: DateTimeNullableWithAggregatesFilter<"Opportunity"> | Date | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Opportunity"> | Date | string
  }

  export type OpportunityLikeWhereInput = {
    AND?: OpportunityLikeWhereInput | OpportunityLikeWhereInput[]
    OR?: OpportunityLikeWhereInput[]
    NOT?: OpportunityLikeWhereInput | OpportunityLikeWhereInput[]
    id?: StringFilter<"OpportunityLike"> | string
    userId?: StringFilter<"OpportunityLike"> | string
    opportunityId?: StringFilter<"OpportunityLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    opportunity?: XOR<OpportunityRelationFilter, OpportunityWhereInput>
  }

  export type OpportunityLikeOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    user?: UserOrderByWithRelationInput
    opportunity?: OpportunityOrderByWithRelationInput
  }

  export type OpportunityLikeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OpportunityLikeWhereInput | OpportunityLikeWhereInput[]
    OR?: OpportunityLikeWhereInput[]
    NOT?: OpportunityLikeWhereInput | OpportunityLikeWhereInput[]
    userId?: StringFilter<"OpportunityLike"> | string
    opportunityId?: StringFilter<"OpportunityLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    opportunity?: XOR<OpportunityRelationFilter, OpportunityWhereInput>
  }, "id">

  export type OpportunityLikeOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    _count?: OpportunityLikeCountOrderByAggregateInput
    _max?: OpportunityLikeMaxOrderByAggregateInput
    _min?: OpportunityLikeMinOrderByAggregateInput
  }

  export type OpportunityLikeScalarWhereWithAggregatesInput = {
    AND?: OpportunityLikeScalarWhereWithAggregatesInput | OpportunityLikeScalarWhereWithAggregatesInput[]
    OR?: OpportunityLikeScalarWhereWithAggregatesInput[]
    NOT?: OpportunityLikeScalarWhereWithAggregatesInput | OpportunityLikeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"OpportunityLike"> | string
    userId?: StringWithAggregatesFilter<"OpportunityLike"> | string
    opportunityId?: StringWithAggregatesFilter<"OpportunityLike"> | string
  }

  export type OpportunityCommentWhereInput = {
    AND?: OpportunityCommentWhereInput | OpportunityCommentWhereInput[]
    OR?: OpportunityCommentWhereInput[]
    NOT?: OpportunityCommentWhereInput | OpportunityCommentWhereInput[]
    id?: StringFilter<"OpportunityComment"> | string
    content?: StringFilter<"OpportunityComment"> | string
    userId?: StringFilter<"OpportunityComment"> | string
    opportunityId?: StringFilter<"OpportunityComment"> | string
    createdAt?: DateTimeFilter<"OpportunityComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    opportunity?: XOR<OpportunityRelationFilter, OpportunityWhereInput>
  }

  export type OpportunityCommentOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    opportunity?: OpportunityOrderByWithRelationInput
  }

  export type OpportunityCommentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OpportunityCommentWhereInput | OpportunityCommentWhereInput[]
    OR?: OpportunityCommentWhereInput[]
    NOT?: OpportunityCommentWhereInput | OpportunityCommentWhereInput[]
    content?: StringFilter<"OpportunityComment"> | string
    userId?: StringFilter<"OpportunityComment"> | string
    opportunityId?: StringFilter<"OpportunityComment"> | string
    createdAt?: DateTimeFilter<"OpportunityComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    opportunity?: XOR<OpportunityRelationFilter, OpportunityWhereInput>
  }, "id">

  export type OpportunityCommentOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    createdAt?: SortOrder
    _count?: OpportunityCommentCountOrderByAggregateInput
    _max?: OpportunityCommentMaxOrderByAggregateInput
    _min?: OpportunityCommentMinOrderByAggregateInput
  }

  export type OpportunityCommentScalarWhereWithAggregatesInput = {
    AND?: OpportunityCommentScalarWhereWithAggregatesInput | OpportunityCommentScalarWhereWithAggregatesInput[]
    OR?: OpportunityCommentScalarWhereWithAggregatesInput[]
    NOT?: OpportunityCommentScalarWhereWithAggregatesInput | OpportunityCommentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"OpportunityComment"> | string
    content?: StringWithAggregatesFilter<"OpportunityComment"> | string
    userId?: StringWithAggregatesFilter<"OpportunityComment"> | string
    opportunityId?: StringWithAggregatesFilter<"OpportunityComment"> | string
    createdAt?: DateTimeWithAggregatesFilter<"OpportunityComment"> | Date | string
  }

  export type EventWhereInput = {
    AND?: EventWhereInput | EventWhereInput[]
    OR?: EventWhereInput[]
    NOT?: EventWhereInput | EventWhereInput[]
    id?: StringFilter<"Event"> | string
    title?: StringFilter<"Event"> | string
    briefDescription?: StringFilter<"Event"> | string
    description?: StringFilter<"Event"> | string
    date?: DateTimeFilter<"Event"> | Date | string
    active?: BoolFilter<"Event"> | boolean
    images?: StringNullableListFilter<"Event">
    likes?: EventLikeListRelationFilter
    comments?: EventCommentListRelationFilter
  }

  export type EventOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    active?: SortOrder
    images?: SortOrder
    likes?: EventLikeOrderByRelationAggregateInput
    comments?: EventCommentOrderByRelationAggregateInput
  }

  export type EventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EventWhereInput | EventWhereInput[]
    OR?: EventWhereInput[]
    NOT?: EventWhereInput | EventWhereInput[]
    title?: StringFilter<"Event"> | string
    briefDescription?: StringFilter<"Event"> | string
    description?: StringFilter<"Event"> | string
    date?: DateTimeFilter<"Event"> | Date | string
    active?: BoolFilter<"Event"> | boolean
    images?: StringNullableListFilter<"Event">
    likes?: EventLikeListRelationFilter
    comments?: EventCommentListRelationFilter
  }, "id">

  export type EventOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    active?: SortOrder
    images?: SortOrder
    _count?: EventCountOrderByAggregateInput
    _max?: EventMaxOrderByAggregateInput
    _min?: EventMinOrderByAggregateInput
  }

  export type EventScalarWhereWithAggregatesInput = {
    AND?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
    OR?: EventScalarWhereWithAggregatesInput[]
    NOT?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Event"> | string
    title?: StringWithAggregatesFilter<"Event"> | string
    briefDescription?: StringWithAggregatesFilter<"Event"> | string
    description?: StringWithAggregatesFilter<"Event"> | string
    date?: DateTimeWithAggregatesFilter<"Event"> | Date | string
    active?: BoolWithAggregatesFilter<"Event"> | boolean
    images?: StringNullableListFilter<"Event">
  }

  export type EventLikeWhereInput = {
    AND?: EventLikeWhereInput | EventLikeWhereInput[]
    OR?: EventLikeWhereInput[]
    NOT?: EventLikeWhereInput | EventLikeWhereInput[]
    id?: StringFilter<"EventLike"> | string
    userId?: StringFilter<"EventLike"> | string
    eventId?: StringFilter<"EventLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    event?: XOR<EventRelationFilter, EventWhereInput>
  }

  export type EventLikeOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    user?: UserOrderByWithRelationInput
    event?: EventOrderByWithRelationInput
  }

  export type EventLikeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EventLikeWhereInput | EventLikeWhereInput[]
    OR?: EventLikeWhereInput[]
    NOT?: EventLikeWhereInput | EventLikeWhereInput[]
    userId?: StringFilter<"EventLike"> | string
    eventId?: StringFilter<"EventLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    event?: XOR<EventRelationFilter, EventWhereInput>
  }, "id">

  export type EventLikeOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    _count?: EventLikeCountOrderByAggregateInput
    _max?: EventLikeMaxOrderByAggregateInput
    _min?: EventLikeMinOrderByAggregateInput
  }

  export type EventLikeScalarWhereWithAggregatesInput = {
    AND?: EventLikeScalarWhereWithAggregatesInput | EventLikeScalarWhereWithAggregatesInput[]
    OR?: EventLikeScalarWhereWithAggregatesInput[]
    NOT?: EventLikeScalarWhereWithAggregatesInput | EventLikeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"EventLike"> | string
    userId?: StringWithAggregatesFilter<"EventLike"> | string
    eventId?: StringWithAggregatesFilter<"EventLike"> | string
  }

  export type EventCommentWhereInput = {
    AND?: EventCommentWhereInput | EventCommentWhereInput[]
    OR?: EventCommentWhereInput[]
    NOT?: EventCommentWhereInput | EventCommentWhereInput[]
    id?: StringFilter<"EventComment"> | string
    content?: StringFilter<"EventComment"> | string
    userId?: StringFilter<"EventComment"> | string
    eventId?: StringFilter<"EventComment"> | string
    createdAt?: DateTimeFilter<"EventComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    event?: XOR<EventRelationFilter, EventWhereInput>
  }

  export type EventCommentOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    event?: EventOrderByWithRelationInput
  }

  export type EventCommentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EventCommentWhereInput | EventCommentWhereInput[]
    OR?: EventCommentWhereInput[]
    NOT?: EventCommentWhereInput | EventCommentWhereInput[]
    content?: StringFilter<"EventComment"> | string
    userId?: StringFilter<"EventComment"> | string
    eventId?: StringFilter<"EventComment"> | string
    createdAt?: DateTimeFilter<"EventComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    event?: XOR<EventRelationFilter, EventWhereInput>
  }, "id">

  export type EventCommentOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    createdAt?: SortOrder
    _count?: EventCommentCountOrderByAggregateInput
    _max?: EventCommentMaxOrderByAggregateInput
    _min?: EventCommentMinOrderByAggregateInput
  }

  export type EventCommentScalarWhereWithAggregatesInput = {
    AND?: EventCommentScalarWhereWithAggregatesInput | EventCommentScalarWhereWithAggregatesInput[]
    OR?: EventCommentScalarWhereWithAggregatesInput[]
    NOT?: EventCommentScalarWhereWithAggregatesInput | EventCommentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"EventComment"> | string
    content?: StringWithAggregatesFilter<"EventComment"> | string
    userId?: StringWithAggregatesFilter<"EventComment"> | string
    eventId?: StringWithAggregatesFilter<"EventComment"> | string
    createdAt?: DateTimeWithAggregatesFilter<"EventComment"> | Date | string
  }

  export type AppointmentWhereInput = {
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    id?: StringFilter<"Appointment"> | string
    title?: StringFilter<"Appointment"> | string
    briefDescription?: StringFilter<"Appointment"> | string
    description?: StringFilter<"Appointment"> | string
    date?: DateTimeFilter<"Appointment"> | Date | string
    time?: StringFilter<"Appointment"> | string
    activationDate?: DateTimeFilter<"Appointment"> | Date | string
    address?: StringFilter<"Appointment"> | string
    active?: BoolFilter<"Appointment"> | boolean
    images?: StringNullableListFilter<"Appointment">
    likes?: AppointmentLikeListRelationFilter
    comments?: AppointmentCommentListRelationFilter
    registrations?: AppointmentRegistrationListRelationFilter
  }

  export type AppointmentOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    time?: SortOrder
    activationDate?: SortOrder
    address?: SortOrder
    active?: SortOrder
    images?: SortOrder
    likes?: AppointmentLikeOrderByRelationAggregateInput
    comments?: AppointmentCommentOrderByRelationAggregateInput
    registrations?: AppointmentRegistrationOrderByRelationAggregateInput
  }

  export type AppointmentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    title?: StringFilter<"Appointment"> | string
    briefDescription?: StringFilter<"Appointment"> | string
    description?: StringFilter<"Appointment"> | string
    date?: DateTimeFilter<"Appointment"> | Date | string
    time?: StringFilter<"Appointment"> | string
    activationDate?: DateTimeFilter<"Appointment"> | Date | string
    address?: StringFilter<"Appointment"> | string
    active?: BoolFilter<"Appointment"> | boolean
    images?: StringNullableListFilter<"Appointment">
    likes?: AppointmentLikeListRelationFilter
    comments?: AppointmentCommentListRelationFilter
    registrations?: AppointmentRegistrationListRelationFilter
  }, "id">

  export type AppointmentOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    time?: SortOrder
    activationDate?: SortOrder
    address?: SortOrder
    active?: SortOrder
    images?: SortOrder
    _count?: AppointmentCountOrderByAggregateInput
    _max?: AppointmentMaxOrderByAggregateInput
    _min?: AppointmentMinOrderByAggregateInput
  }

  export type AppointmentScalarWhereWithAggregatesInput = {
    AND?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    OR?: AppointmentScalarWhereWithAggregatesInput[]
    NOT?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Appointment"> | string
    title?: StringWithAggregatesFilter<"Appointment"> | string
    briefDescription?: StringWithAggregatesFilter<"Appointment"> | string
    description?: StringWithAggregatesFilter<"Appointment"> | string
    date?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    time?: StringWithAggregatesFilter<"Appointment"> | string
    activationDate?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    address?: StringWithAggregatesFilter<"Appointment"> | string
    active?: BoolWithAggregatesFilter<"Appointment"> | boolean
    images?: StringNullableListFilter<"Appointment">
  }

  export type AppointmentLikeWhereInput = {
    AND?: AppointmentLikeWhereInput | AppointmentLikeWhereInput[]
    OR?: AppointmentLikeWhereInput[]
    NOT?: AppointmentLikeWhereInput | AppointmentLikeWhereInput[]
    id?: StringFilter<"AppointmentLike"> | string
    userId?: StringFilter<"AppointmentLike"> | string
    appointmentId?: StringFilter<"AppointmentLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }

  export type AppointmentLikeOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    user?: UserOrderByWithRelationInput
    appointment?: AppointmentOrderByWithRelationInput
  }

  export type AppointmentLikeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AppointmentLikeWhereInput | AppointmentLikeWhereInput[]
    OR?: AppointmentLikeWhereInput[]
    NOT?: AppointmentLikeWhereInput | AppointmentLikeWhereInput[]
    userId?: StringFilter<"AppointmentLike"> | string
    appointmentId?: StringFilter<"AppointmentLike"> | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }, "id">

  export type AppointmentLikeOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    _count?: AppointmentLikeCountOrderByAggregateInput
    _max?: AppointmentLikeMaxOrderByAggregateInput
    _min?: AppointmentLikeMinOrderByAggregateInput
  }

  export type AppointmentLikeScalarWhereWithAggregatesInput = {
    AND?: AppointmentLikeScalarWhereWithAggregatesInput | AppointmentLikeScalarWhereWithAggregatesInput[]
    OR?: AppointmentLikeScalarWhereWithAggregatesInput[]
    NOT?: AppointmentLikeScalarWhereWithAggregatesInput | AppointmentLikeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AppointmentLike"> | string
    userId?: StringWithAggregatesFilter<"AppointmentLike"> | string
    appointmentId?: StringWithAggregatesFilter<"AppointmentLike"> | string
  }

  export type AppointmentCommentWhereInput = {
    AND?: AppointmentCommentWhereInput | AppointmentCommentWhereInput[]
    OR?: AppointmentCommentWhereInput[]
    NOT?: AppointmentCommentWhereInput | AppointmentCommentWhereInput[]
    id?: StringFilter<"AppointmentComment"> | string
    content?: StringFilter<"AppointmentComment"> | string
    userId?: StringFilter<"AppointmentComment"> | string
    appointmentId?: StringFilter<"AppointmentComment"> | string
    createdAt?: DateTimeFilter<"AppointmentComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }

  export type AppointmentCommentOrderByWithRelationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    appointment?: AppointmentOrderByWithRelationInput
  }

  export type AppointmentCommentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AppointmentCommentWhereInput | AppointmentCommentWhereInput[]
    OR?: AppointmentCommentWhereInput[]
    NOT?: AppointmentCommentWhereInput | AppointmentCommentWhereInput[]
    content?: StringFilter<"AppointmentComment"> | string
    userId?: StringFilter<"AppointmentComment"> | string
    appointmentId?: StringFilter<"AppointmentComment"> | string
    createdAt?: DateTimeFilter<"AppointmentComment"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }, "id">

  export type AppointmentCommentOrderByWithAggregationInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
    _count?: AppointmentCommentCountOrderByAggregateInput
    _max?: AppointmentCommentMaxOrderByAggregateInput
    _min?: AppointmentCommentMinOrderByAggregateInput
  }

  export type AppointmentCommentScalarWhereWithAggregatesInput = {
    AND?: AppointmentCommentScalarWhereWithAggregatesInput | AppointmentCommentScalarWhereWithAggregatesInput[]
    OR?: AppointmentCommentScalarWhereWithAggregatesInput[]
    NOT?: AppointmentCommentScalarWhereWithAggregatesInput | AppointmentCommentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AppointmentComment"> | string
    content?: StringWithAggregatesFilter<"AppointmentComment"> | string
    userId?: StringWithAggregatesFilter<"AppointmentComment"> | string
    appointmentId?: StringWithAggregatesFilter<"AppointmentComment"> | string
    createdAt?: DateTimeWithAggregatesFilter<"AppointmentComment"> | Date | string
  }

  export type AppointmentRegistrationWhereInput = {
    AND?: AppointmentRegistrationWhereInput | AppointmentRegistrationWhereInput[]
    OR?: AppointmentRegistrationWhereInput[]
    NOT?: AppointmentRegistrationWhereInput | AppointmentRegistrationWhereInput[]
    id?: StringFilter<"AppointmentRegistration"> | string
    userId?: StringFilter<"AppointmentRegistration"> | string
    appointmentId?: StringFilter<"AppointmentRegistration"> | string
    createdAt?: DateTimeFilter<"AppointmentRegistration"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }

  export type AppointmentRegistrationOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    appointment?: AppointmentOrderByWithRelationInput
  }

  export type AppointmentRegistrationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AppointmentRegistrationWhereInput | AppointmentRegistrationWhereInput[]
    OR?: AppointmentRegistrationWhereInput[]
    NOT?: AppointmentRegistrationWhereInput | AppointmentRegistrationWhereInput[]
    userId?: StringFilter<"AppointmentRegistration"> | string
    appointmentId?: StringFilter<"AppointmentRegistration"> | string
    createdAt?: DateTimeFilter<"AppointmentRegistration"> | Date | string
    user?: XOR<UserRelationFilter, UserWhereInput>
    appointment?: XOR<AppointmentRelationFilter, AppointmentWhereInput>
  }, "id">

  export type AppointmentRegistrationOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
    _count?: AppointmentRegistrationCountOrderByAggregateInput
    _max?: AppointmentRegistrationMaxOrderByAggregateInput
    _min?: AppointmentRegistrationMinOrderByAggregateInput
  }

  export type AppointmentRegistrationScalarWhereWithAggregatesInput = {
    AND?: AppointmentRegistrationScalarWhereWithAggregatesInput | AppointmentRegistrationScalarWhereWithAggregatesInput[]
    OR?: AppointmentRegistrationScalarWhereWithAggregatesInput[]
    NOT?: AppointmentRegistrationScalarWhereWithAggregatesInput | AppointmentRegistrationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AppointmentRegistration"> | string
    userId?: StringWithAggregatesFilter<"AppointmentRegistration"> | string
    appointmentId?: StringWithAggregatesFilter<"AppointmentRegistration"> | string
    createdAt?: DateTimeWithAggregatesFilter<"AppointmentRegistration"> | Date | string
  }

  export type AlbumWhereInput = {
    AND?: AlbumWhereInput | AlbumWhereInput[]
    OR?: AlbumWhereInput[]
    NOT?: AlbumWhereInput | AlbumWhereInput[]
    id?: StringFilter<"Album"> | string
    title?: StringFilter<"Album"> | string
    date?: DateTimeFilter<"Album"> | Date | string
    images?: StringNullableListFilter<"Album">
  }

  export type AlbumOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    images?: SortOrder
  }

  export type AlbumWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AlbumWhereInput | AlbumWhereInput[]
    OR?: AlbumWhereInput[]
    NOT?: AlbumWhereInput | AlbumWhereInput[]
    title?: StringFilter<"Album"> | string
    date?: DateTimeFilter<"Album"> | Date | string
    images?: StringNullableListFilter<"Album">
  }, "id">

  export type AlbumOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    images?: SortOrder
    _count?: AlbumCountOrderByAggregateInput
    _max?: AlbumMaxOrderByAggregateInput
    _min?: AlbumMinOrderByAggregateInput
  }

  export type AlbumScalarWhereWithAggregatesInput = {
    AND?: AlbumScalarWhereWithAggregatesInput | AlbumScalarWhereWithAggregatesInput[]
    OR?: AlbumScalarWhereWithAggregatesInput[]
    NOT?: AlbumScalarWhereWithAggregatesInput | AlbumScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Album"> | string
    title?: StringWithAggregatesFilter<"Album"> | string
    date?: DateTimeWithAggregatesFilter<"Album"> | Date | string
    images?: StringNullableListFilter<"Album">
  }

  export type VideoWhereInput = {
    AND?: VideoWhereInput | VideoWhereInput[]
    OR?: VideoWhereInput[]
    NOT?: VideoWhereInput | VideoWhereInput[]
    id?: StringFilter<"Video"> | string
    title?: StringFilter<"Video"> | string
    date?: DateTimeFilter<"Video"> | Date | string
    link?: StringFilter<"Video"> | string
  }

  export type VideoOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    link?: SortOrder
  }

  export type VideoWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VideoWhereInput | VideoWhereInput[]
    OR?: VideoWhereInput[]
    NOT?: VideoWhereInput | VideoWhereInput[]
    title?: StringFilter<"Video"> | string
    date?: DateTimeFilter<"Video"> | Date | string
    link?: StringFilter<"Video"> | string
  }, "id">

  export type VideoOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    link?: SortOrder
    _count?: VideoCountOrderByAggregateInput
    _max?: VideoMaxOrderByAggregateInput
    _min?: VideoMinOrderByAggregateInput
  }

  export type VideoScalarWhereWithAggregatesInput = {
    AND?: VideoScalarWhereWithAggregatesInput | VideoScalarWhereWithAggregatesInput[]
    OR?: VideoScalarWhereWithAggregatesInput[]
    NOT?: VideoScalarWhereWithAggregatesInput | VideoScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Video"> | string
    title?: StringWithAggregatesFilter<"Video"> | string
    date?: DateTimeWithAggregatesFilter<"Video"> | Date | string
    link?: StringWithAggregatesFilter<"Video"> | string
  }

  export type EditionWhereInput = {
    AND?: EditionWhereInput | EditionWhereInput[]
    OR?: EditionWhereInput[]
    NOT?: EditionWhereInput | EditionWhereInput[]
    id?: StringFilter<"Edition"> | string
    title?: StringFilter<"Edition"> | string
    categoryId?: StringFilter<"Edition"> | string
    document?: StringFilter<"Edition"> | string
    image?: StringNullableFilter<"Edition"> | string | null
    category?: XOR<CategoryRelationFilter, CategoryWhereInput>
  }

  export type EditionOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    categoryId?: SortOrder
    document?: SortOrder
    image?: SortOrderInput | SortOrder
    category?: CategoryOrderByWithRelationInput
  }

  export type EditionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EditionWhereInput | EditionWhereInput[]
    OR?: EditionWhereInput[]
    NOT?: EditionWhereInput | EditionWhereInput[]
    title?: StringFilter<"Edition"> | string
    categoryId?: StringFilter<"Edition"> | string
    document?: StringFilter<"Edition"> | string
    image?: StringNullableFilter<"Edition"> | string | null
    category?: XOR<CategoryRelationFilter, CategoryWhereInput>
  }, "id">

  export type EditionOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    categoryId?: SortOrder
    document?: SortOrder
    image?: SortOrderInput | SortOrder
    _count?: EditionCountOrderByAggregateInput
    _max?: EditionMaxOrderByAggregateInput
    _min?: EditionMinOrderByAggregateInput
  }

  export type EditionScalarWhereWithAggregatesInput = {
    AND?: EditionScalarWhereWithAggregatesInput | EditionScalarWhereWithAggregatesInput[]
    OR?: EditionScalarWhereWithAggregatesInput[]
    NOT?: EditionScalarWhereWithAggregatesInput | EditionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Edition"> | string
    title?: StringWithAggregatesFilter<"Edition"> | string
    categoryId?: StringWithAggregatesFilter<"Edition"> | string
    document?: StringWithAggregatesFilter<"Edition"> | string
    image?: StringNullableWithAggregatesFilter<"Edition"> | string | null
  }

  export type TrainingWhereInput = {
    AND?: TrainingWhereInput | TrainingWhereInput[]
    OR?: TrainingWhereInput[]
    NOT?: TrainingWhereInput | TrainingWhereInput[]
    id?: StringFilter<"Training"> | string
    title?: StringFilter<"Training"> | string
    place?: StringFilter<"Training"> | string
    date?: DateTimeFilter<"Training"> | Date | string
    email?: StringFilter<"Training"> | string
    phoneNumber?: StringFilter<"Training"> | string
    website?: StringFilter<"Training"> | string
    type?: EnumTrainingTypeFilter<"Training"> | $Enums.TrainingType
    description?: StringFilter<"Training"> | string
    document?: StringNullableFilter<"Training"> | string | null
  }

  export type TrainingOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    place?: SortOrder
    date?: SortOrder
    email?: SortOrder
    phoneNumber?: SortOrder
    website?: SortOrder
    type?: SortOrder
    description?: SortOrder
    document?: SortOrderInput | SortOrder
  }

  export type TrainingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TrainingWhereInput | TrainingWhereInput[]
    OR?: TrainingWhereInput[]
    NOT?: TrainingWhereInput | TrainingWhereInput[]
    title?: StringFilter<"Training"> | string
    place?: StringFilter<"Training"> | string
    date?: DateTimeFilter<"Training"> | Date | string
    email?: StringFilter<"Training"> | string
    phoneNumber?: StringFilter<"Training"> | string
    website?: StringFilter<"Training"> | string
    type?: EnumTrainingTypeFilter<"Training"> | $Enums.TrainingType
    description?: StringFilter<"Training"> | string
    document?: StringNullableFilter<"Training"> | string | null
  }, "id">

  export type TrainingOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    place?: SortOrder
    date?: SortOrder
    email?: SortOrder
    phoneNumber?: SortOrder
    website?: SortOrder
    type?: SortOrder
    description?: SortOrder
    document?: SortOrderInput | SortOrder
    _count?: TrainingCountOrderByAggregateInput
    _max?: TrainingMaxOrderByAggregateInput
    _min?: TrainingMinOrderByAggregateInput
  }

  export type TrainingScalarWhereWithAggregatesInput = {
    AND?: TrainingScalarWhereWithAggregatesInput | TrainingScalarWhereWithAggregatesInput[]
    OR?: TrainingScalarWhereWithAggregatesInput[]
    NOT?: TrainingScalarWhereWithAggregatesInput | TrainingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Training"> | string
    title?: StringWithAggregatesFilter<"Training"> | string
    place?: StringWithAggregatesFilter<"Training"> | string
    date?: DateTimeWithAggregatesFilter<"Training"> | Date | string
    email?: StringWithAggregatesFilter<"Training"> | string
    phoneNumber?: StringWithAggregatesFilter<"Training"> | string
    website?: StringWithAggregatesFilter<"Training"> | string
    type?: EnumTrainingTypeWithAggregatesFilter<"Training"> | $Enums.TrainingType
    description?: StringWithAggregatesFilter<"Training"> | string
    document?: StringNullableWithAggregatesFilter<"Training"> | string | null
  }

  export type FairWhereInput = {
    AND?: FairWhereInput | FairWhereInput[]
    OR?: FairWhereInput[]
    NOT?: FairWhereInput | FairWhereInput[]
    id?: StringFilter<"Fair"> | string
    title?: StringFilter<"Fair"> | string
    country?: StringFilter<"Fair"> | string
    place?: StringFilter<"Fair"> | string
    startDate?: DateTimeFilter<"Fair"> | Date | string
    endDate?: DateTimeFilter<"Fair"> | Date | string
    sector?: StringFilter<"Fair"> | string
    organizer?: StringFilter<"Fair"> | string
    phoneNumber?: StringFilter<"Fair"> | string
    fax?: StringFilter<"Fair"> | string
    email?: StringFilter<"Fair"> | string
    website?: StringFilter<"Fair"> | string
  }

  export type FairOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    country?: SortOrder
    place?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
    sector?: SortOrder
    organizer?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
  }

  export type FairWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FairWhereInput | FairWhereInput[]
    OR?: FairWhereInput[]
    NOT?: FairWhereInput | FairWhereInput[]
    title?: StringFilter<"Fair"> | string
    country?: StringFilter<"Fair"> | string
    place?: StringFilter<"Fair"> | string
    startDate?: DateTimeFilter<"Fair"> | Date | string
    endDate?: DateTimeFilter<"Fair"> | Date | string
    sector?: StringFilter<"Fair"> | string
    organizer?: StringFilter<"Fair"> | string
    phoneNumber?: StringFilter<"Fair"> | string
    fax?: StringFilter<"Fair"> | string
    email?: StringFilter<"Fair"> | string
    website?: StringFilter<"Fair"> | string
  }, "id">

  export type FairOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    country?: SortOrder
    place?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
    sector?: SortOrder
    organizer?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    _count?: FairCountOrderByAggregateInput
    _max?: FairMaxOrderByAggregateInput
    _min?: FairMinOrderByAggregateInput
  }

  export type FairScalarWhereWithAggregatesInput = {
    AND?: FairScalarWhereWithAggregatesInput | FairScalarWhereWithAggregatesInput[]
    OR?: FairScalarWhereWithAggregatesInput[]
    NOT?: FairScalarWhereWithAggregatesInput | FairScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Fair"> | string
    title?: StringWithAggregatesFilter<"Fair"> | string
    country?: StringWithAggregatesFilter<"Fair"> | string
    place?: StringWithAggregatesFilter<"Fair"> | string
    startDate?: DateTimeWithAggregatesFilter<"Fair"> | Date | string
    endDate?: DateTimeWithAggregatesFilter<"Fair"> | Date | string
    sector?: StringWithAggregatesFilter<"Fair"> | string
    organizer?: StringWithAggregatesFilter<"Fair"> | string
    phoneNumber?: StringWithAggregatesFilter<"Fair"> | string
    fax?: StringWithAggregatesFilter<"Fair"> | string
    email?: StringWithAggregatesFilter<"Fair"> | string
    website?: StringWithAggregatesFilter<"Fair"> | string
  }

  export type BusinessPlanWhereInput = {
    AND?: BusinessPlanWhereInput | BusinessPlanWhereInput[]
    OR?: BusinessPlanWhereInput[]
    NOT?: BusinessPlanWhereInput | BusinessPlanWhereInput[]
    id?: StringFilter<"BusinessPlan"> | string
    firstName?: StringFilter<"BusinessPlan"> | string
    lastName?: StringFilter<"BusinessPlan"> | string
    nationality?: StringFilter<"BusinessPlan"> | string
    phoneNumber?: StringFilter<"BusinessPlan"> | string
    email?: StringFilter<"BusinessPlan"> | string
    projectIdea?: StringFilter<"BusinessPlan"> | string
    location?: StringFilter<"BusinessPlan"> | string
    educationAndExperience?: StringFilter<"BusinessPlan"> | string
    financingPlan?: StringFilter<"BusinessPlan"> | string
    createdAt?: DateTimeFilter<"BusinessPlan"> | Date | string
  }

  export type BusinessPlanOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    nationality?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    projectIdea?: SortOrder
    location?: SortOrder
    educationAndExperience?: SortOrder
    financingPlan?: SortOrder
    createdAt?: SortOrder
  }

  export type BusinessPlanWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BusinessPlanWhereInput | BusinessPlanWhereInput[]
    OR?: BusinessPlanWhereInput[]
    NOT?: BusinessPlanWhereInput | BusinessPlanWhereInput[]
    firstName?: StringFilter<"BusinessPlan"> | string
    lastName?: StringFilter<"BusinessPlan"> | string
    nationality?: StringFilter<"BusinessPlan"> | string
    phoneNumber?: StringFilter<"BusinessPlan"> | string
    email?: StringFilter<"BusinessPlan"> | string
    projectIdea?: StringFilter<"BusinessPlan"> | string
    location?: StringFilter<"BusinessPlan"> | string
    educationAndExperience?: StringFilter<"BusinessPlan"> | string
    financingPlan?: StringFilter<"BusinessPlan"> | string
    createdAt?: DateTimeFilter<"BusinessPlan"> | Date | string
  }, "id">

  export type BusinessPlanOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    nationality?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    projectIdea?: SortOrder
    location?: SortOrder
    educationAndExperience?: SortOrder
    financingPlan?: SortOrder
    createdAt?: SortOrder
    _count?: BusinessPlanCountOrderByAggregateInput
    _max?: BusinessPlanMaxOrderByAggregateInput
    _min?: BusinessPlanMinOrderByAggregateInput
  }

  export type BusinessPlanScalarWhereWithAggregatesInput = {
    AND?: BusinessPlanScalarWhereWithAggregatesInput | BusinessPlanScalarWhereWithAggregatesInput[]
    OR?: BusinessPlanScalarWhereWithAggregatesInput[]
    NOT?: BusinessPlanScalarWhereWithAggregatesInput | BusinessPlanScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"BusinessPlan"> | string
    firstName?: StringWithAggregatesFilter<"BusinessPlan"> | string
    lastName?: StringWithAggregatesFilter<"BusinessPlan"> | string
    nationality?: StringWithAggregatesFilter<"BusinessPlan"> | string
    phoneNumber?: StringWithAggregatesFilter<"BusinessPlan"> | string
    email?: StringWithAggregatesFilter<"BusinessPlan"> | string
    projectIdea?: StringWithAggregatesFilter<"BusinessPlan"> | string
    location?: StringWithAggregatesFilter<"BusinessPlan"> | string
    educationAndExperience?: StringWithAggregatesFilter<"BusinessPlan"> | string
    financingPlan?: StringWithAggregatesFilter<"BusinessPlan"> | string
    createdAt?: DateTimeWithAggregatesFilter<"BusinessPlan"> | Date | string
  }

  export type MarketResearchWhereInput = {
    AND?: MarketResearchWhereInput | MarketResearchWhereInput[]
    OR?: MarketResearchWhereInput[]
    NOT?: MarketResearchWhereInput | MarketResearchWhereInput[]
    id?: StringFilter<"MarketResearch"> | string
    firstName?: StringFilter<"MarketResearch"> | string
    lastName?: StringFilter<"MarketResearch"> | string
    phoneNumber?: StringFilter<"MarketResearch"> | string
    email?: StringFilter<"MarketResearch"> | string
    address?: StringFilter<"MarketResearch"> | string
    city?: StringFilter<"MarketResearch"> | string
    state?: StringFilter<"MarketResearch"> | string
    zipCode?: StringFilter<"MarketResearch"> | string
    country?: StringFilter<"MarketResearch"> | string
    projectIdea?: StringFilter<"MarketResearch"> | string
    educationAndExperience?: StringFilter<"MarketResearch"> | string
    createdAt?: DateTimeFilter<"MarketResearch"> | Date | string
  }

  export type MarketResearchOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
    country?: SortOrder
    projectIdea?: SortOrder
    educationAndExperience?: SortOrder
    createdAt?: SortOrder
  }

  export type MarketResearchWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MarketResearchWhereInput | MarketResearchWhereInput[]
    OR?: MarketResearchWhereInput[]
    NOT?: MarketResearchWhereInput | MarketResearchWhereInput[]
    firstName?: StringFilter<"MarketResearch"> | string
    lastName?: StringFilter<"MarketResearch"> | string
    phoneNumber?: StringFilter<"MarketResearch"> | string
    email?: StringFilter<"MarketResearch"> | string
    address?: StringFilter<"MarketResearch"> | string
    city?: StringFilter<"MarketResearch"> | string
    state?: StringFilter<"MarketResearch"> | string
    zipCode?: StringFilter<"MarketResearch"> | string
    country?: StringFilter<"MarketResearch"> | string
    projectIdea?: StringFilter<"MarketResearch"> | string
    educationAndExperience?: StringFilter<"MarketResearch"> | string
    createdAt?: DateTimeFilter<"MarketResearch"> | Date | string
  }, "id">

  export type MarketResearchOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
    country?: SortOrder
    projectIdea?: SortOrder
    educationAndExperience?: SortOrder
    createdAt?: SortOrder
    _count?: MarketResearchCountOrderByAggregateInput
    _max?: MarketResearchMaxOrderByAggregateInput
    _min?: MarketResearchMinOrderByAggregateInput
  }

  export type MarketResearchScalarWhereWithAggregatesInput = {
    AND?: MarketResearchScalarWhereWithAggregatesInput | MarketResearchScalarWhereWithAggregatesInput[]
    OR?: MarketResearchScalarWhereWithAggregatesInput[]
    NOT?: MarketResearchScalarWhereWithAggregatesInput | MarketResearchScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MarketResearch"> | string
    firstName?: StringWithAggregatesFilter<"MarketResearch"> | string
    lastName?: StringWithAggregatesFilter<"MarketResearch"> | string
    phoneNumber?: StringWithAggregatesFilter<"MarketResearch"> | string
    email?: StringWithAggregatesFilter<"MarketResearch"> | string
    address?: StringWithAggregatesFilter<"MarketResearch"> | string
    city?: StringWithAggregatesFilter<"MarketResearch"> | string
    state?: StringWithAggregatesFilter<"MarketResearch"> | string
    zipCode?: StringWithAggregatesFilter<"MarketResearch"> | string
    country?: StringWithAggregatesFilter<"MarketResearch"> | string
    projectIdea?: StringWithAggregatesFilter<"MarketResearch"> | string
    educationAndExperience?: StringWithAggregatesFilter<"MarketResearch"> | string
    createdAt?: DateTimeWithAggregatesFilter<"MarketResearch"> | Date | string
  }

  export type NetworkingWhereInput = {
    AND?: NetworkingWhereInput | NetworkingWhereInput[]
    OR?: NetworkingWhereInput[]
    NOT?: NetworkingWhereInput | NetworkingWhereInput[]
    id?: StringFilter<"Networking"> | string
    firstName?: StringFilter<"Networking"> | string
    lastName?: StringFilter<"Networking"> | string
    phoneNumber?: StringFilter<"Networking"> | string
    email?: StringFilter<"Networking"> | string
    activity?: StringFilter<"Networking"> | string
    needForNetworking?: StringFilter<"Networking"> | string
    createdAt?: DateTimeFilter<"Networking"> | Date | string
  }

  export type NetworkingOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForNetworking?: SortOrder
    createdAt?: SortOrder
  }

  export type NetworkingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: NetworkingWhereInput | NetworkingWhereInput[]
    OR?: NetworkingWhereInput[]
    NOT?: NetworkingWhereInput | NetworkingWhereInput[]
    firstName?: StringFilter<"Networking"> | string
    lastName?: StringFilter<"Networking"> | string
    phoneNumber?: StringFilter<"Networking"> | string
    email?: StringFilter<"Networking"> | string
    activity?: StringFilter<"Networking"> | string
    needForNetworking?: StringFilter<"Networking"> | string
    createdAt?: DateTimeFilter<"Networking"> | Date | string
  }, "id">

  export type NetworkingOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForNetworking?: SortOrder
    createdAt?: SortOrder
    _count?: NetworkingCountOrderByAggregateInput
    _max?: NetworkingMaxOrderByAggregateInput
    _min?: NetworkingMinOrderByAggregateInput
  }

  export type NetworkingScalarWhereWithAggregatesInput = {
    AND?: NetworkingScalarWhereWithAggregatesInput | NetworkingScalarWhereWithAggregatesInput[]
    OR?: NetworkingScalarWhereWithAggregatesInput[]
    NOT?: NetworkingScalarWhereWithAggregatesInput | NetworkingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Networking"> | string
    firstName?: StringWithAggregatesFilter<"Networking"> | string
    lastName?: StringWithAggregatesFilter<"Networking"> | string
    phoneNumber?: StringWithAggregatesFilter<"Networking"> | string
    email?: StringWithAggregatesFilter<"Networking"> | string
    activity?: StringWithAggregatesFilter<"Networking"> | string
    needForNetworking?: StringWithAggregatesFilter<"Networking"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Networking"> | Date | string
  }

  export type SourcingWhereInput = {
    AND?: SourcingWhereInput | SourcingWhereInput[]
    OR?: SourcingWhereInput[]
    NOT?: SourcingWhereInput | SourcingWhereInput[]
    id?: StringFilter<"Sourcing"> | string
    firstName?: StringFilter<"Sourcing"> | string
    lastName?: StringFilter<"Sourcing"> | string
    phoneNumber?: StringFilter<"Sourcing"> | string
    email?: StringFilter<"Sourcing"> | string
    activity?: StringFilter<"Sourcing"> | string
    productsToSource?: StringFilter<"Sourcing"> | string
    createdAt?: DateTimeFilter<"Sourcing"> | Date | string
  }

  export type SourcingOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    productsToSource?: SortOrder
    createdAt?: SortOrder
  }

  export type SourcingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SourcingWhereInput | SourcingWhereInput[]
    OR?: SourcingWhereInput[]
    NOT?: SourcingWhereInput | SourcingWhereInput[]
    firstName?: StringFilter<"Sourcing"> | string
    lastName?: StringFilter<"Sourcing"> | string
    phoneNumber?: StringFilter<"Sourcing"> | string
    email?: StringFilter<"Sourcing"> | string
    activity?: StringFilter<"Sourcing"> | string
    productsToSource?: StringFilter<"Sourcing"> | string
    createdAt?: DateTimeFilter<"Sourcing"> | Date | string
  }, "id">

  export type SourcingOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    productsToSource?: SortOrder
    createdAt?: SortOrder
    _count?: SourcingCountOrderByAggregateInput
    _max?: SourcingMaxOrderByAggregateInput
    _min?: SourcingMinOrderByAggregateInput
  }

  export type SourcingScalarWhereWithAggregatesInput = {
    AND?: SourcingScalarWhereWithAggregatesInput | SourcingScalarWhereWithAggregatesInput[]
    OR?: SourcingScalarWhereWithAggregatesInput[]
    NOT?: SourcingScalarWhereWithAggregatesInput | SourcingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Sourcing"> | string
    firstName?: StringWithAggregatesFilter<"Sourcing"> | string
    lastName?: StringWithAggregatesFilter<"Sourcing"> | string
    phoneNumber?: StringWithAggregatesFilter<"Sourcing"> | string
    email?: StringWithAggregatesFilter<"Sourcing"> | string
    activity?: StringWithAggregatesFilter<"Sourcing"> | string
    productsToSource?: StringWithAggregatesFilter<"Sourcing"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Sourcing"> | Date | string
  }

  export type ProspectingWhereInput = {
    AND?: ProspectingWhereInput | ProspectingWhereInput[]
    OR?: ProspectingWhereInput[]
    NOT?: ProspectingWhereInput | ProspectingWhereInput[]
    id?: StringFilter<"Prospecting"> | string
    firstName?: StringFilter<"Prospecting"> | string
    lastName?: StringFilter<"Prospecting"> | string
    phoneNumber?: StringFilter<"Prospecting"> | string
    email?: StringFilter<"Prospecting"> | string
    activity?: StringFilter<"Prospecting"> | string
    needForProspecting?: StringFilter<"Prospecting"> | string
    createdAt?: DateTimeFilter<"Prospecting"> | Date | string
  }

  export type ProspectingOrderByWithRelationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForProspecting?: SortOrder
    createdAt?: SortOrder
  }

  export type ProspectingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProspectingWhereInput | ProspectingWhereInput[]
    OR?: ProspectingWhereInput[]
    NOT?: ProspectingWhereInput | ProspectingWhereInput[]
    firstName?: StringFilter<"Prospecting"> | string
    lastName?: StringFilter<"Prospecting"> | string
    phoneNumber?: StringFilter<"Prospecting"> | string
    email?: StringFilter<"Prospecting"> | string
    activity?: StringFilter<"Prospecting"> | string
    needForProspecting?: StringFilter<"Prospecting"> | string
    createdAt?: DateTimeFilter<"Prospecting"> | Date | string
  }, "id">

  export type ProspectingOrderByWithAggregationInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForProspecting?: SortOrder
    createdAt?: SortOrder
    _count?: ProspectingCountOrderByAggregateInput
    _max?: ProspectingMaxOrderByAggregateInput
    _min?: ProspectingMinOrderByAggregateInput
  }

  export type ProspectingScalarWhereWithAggregatesInput = {
    AND?: ProspectingScalarWhereWithAggregatesInput | ProspectingScalarWhereWithAggregatesInput[]
    OR?: ProspectingScalarWhereWithAggregatesInput[]
    NOT?: ProspectingScalarWhereWithAggregatesInput | ProspectingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Prospecting"> | string
    firstName?: StringWithAggregatesFilter<"Prospecting"> | string
    lastName?: StringWithAggregatesFilter<"Prospecting"> | string
    phoneNumber?: StringWithAggregatesFilter<"Prospecting"> | string
    email?: StringWithAggregatesFilter<"Prospecting"> | string
    activity?: StringWithAggregatesFilter<"Prospecting"> | string
    needForProspecting?: StringWithAggregatesFilter<"Prospecting"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Prospecting"> | Date | string
  }

  export type SmsLogWhereInput = {
    AND?: SmsLogWhereInput | SmsLogWhereInput[]
    OR?: SmsLogWhereInput[]
    NOT?: SmsLogWhereInput | SmsLogWhereInput[]
    id?: StringFilter<"SmsLog"> | string
    createdAt?: DateTimeFilter<"SmsLog"> | Date | string
    gateway?: StringFilter<"SmsLog"> | string
    senderId?: StringFilter<"SmsLog"> | string
    recipient?: StringFilter<"SmsLog"> | string
    content?: StringFilter<"SmsLog"> | string
    statusCode?: IntNullableFilter<"SmsLog"> | number | null
    statusText?: StringNullableFilter<"SmsLog"> | string | null
    requestUrl?: StringNullableFilter<"SmsLog"> | string | null
    requestBody?: StringNullableFilter<"SmsLog"> | string | null
    responseBody?: StringNullableFilter<"SmsLog"> | string | null
    errorMessage?: StringNullableFilter<"SmsLog"> | string | null
    meta?: JsonNullableFilter<"SmsLog">
    userId?: StringNullableFilter<"SmsLog"> | string | null
  }

  export type SmsLogOrderByWithRelationInput = {
    id?: SortOrder
    createdAt?: SortOrder
    gateway?: SortOrder
    senderId?: SortOrder
    recipient?: SortOrder
    content?: SortOrder
    statusCode?: SortOrderInput | SortOrder
    statusText?: SortOrderInput | SortOrder
    requestUrl?: SortOrderInput | SortOrder
    requestBody?: SortOrderInput | SortOrder
    responseBody?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
    meta?: SortOrderInput | SortOrder
    userId?: SortOrderInput | SortOrder
  }

  export type SmsLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SmsLogWhereInput | SmsLogWhereInput[]
    OR?: SmsLogWhereInput[]
    NOT?: SmsLogWhereInput | SmsLogWhereInput[]
    createdAt?: DateTimeFilter<"SmsLog"> | Date | string
    gateway?: StringFilter<"SmsLog"> | string
    senderId?: StringFilter<"SmsLog"> | string
    recipient?: StringFilter<"SmsLog"> | string
    content?: StringFilter<"SmsLog"> | string
    statusCode?: IntNullableFilter<"SmsLog"> | number | null
    statusText?: StringNullableFilter<"SmsLog"> | string | null
    requestUrl?: StringNullableFilter<"SmsLog"> | string | null
    requestBody?: StringNullableFilter<"SmsLog"> | string | null
    responseBody?: StringNullableFilter<"SmsLog"> | string | null
    errorMessage?: StringNullableFilter<"SmsLog"> | string | null
    meta?: JsonNullableFilter<"SmsLog">
    userId?: StringNullableFilter<"SmsLog"> | string | null
  }, "id">

  export type SmsLogOrderByWithAggregationInput = {
    id?: SortOrder
    createdAt?: SortOrder
    gateway?: SortOrder
    senderId?: SortOrder
    recipient?: SortOrder
    content?: SortOrder
    statusCode?: SortOrderInput | SortOrder
    statusText?: SortOrderInput | SortOrder
    requestUrl?: SortOrderInput | SortOrder
    requestBody?: SortOrderInput | SortOrder
    responseBody?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
    meta?: SortOrderInput | SortOrder
    userId?: SortOrderInput | SortOrder
    _count?: SmsLogCountOrderByAggregateInput
    _avg?: SmsLogAvgOrderByAggregateInput
    _max?: SmsLogMaxOrderByAggregateInput
    _min?: SmsLogMinOrderByAggregateInput
    _sum?: SmsLogSumOrderByAggregateInput
  }

  export type SmsLogScalarWhereWithAggregatesInput = {
    AND?: SmsLogScalarWhereWithAggregatesInput | SmsLogScalarWhereWithAggregatesInput[]
    OR?: SmsLogScalarWhereWithAggregatesInput[]
    NOT?: SmsLogScalarWhereWithAggregatesInput | SmsLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SmsLog"> | string
    createdAt?: DateTimeWithAggregatesFilter<"SmsLog"> | Date | string
    gateway?: StringWithAggregatesFilter<"SmsLog"> | string
    senderId?: StringWithAggregatesFilter<"SmsLog"> | string
    recipient?: StringWithAggregatesFilter<"SmsLog"> | string
    content?: StringWithAggregatesFilter<"SmsLog"> | string
    statusCode?: IntNullableWithAggregatesFilter<"SmsLog"> | number | null
    statusText?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
    requestUrl?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
    requestBody?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
    responseBody?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
    errorMessage?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
    meta?: JsonNullableWithAggregatesFilter<"SmsLog">
    userId?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
  }

  export type CcisCreateInput = {
    id?: string
    presentation: string
    termsOfService: string
    privacyPolicy: string
  }

  export type CcisUncheckedCreateInput = {
    id?: string
    presentation: string
    termsOfService: string
    privacyPolicy: string
  }

  export type CcisUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    presentation?: StringFieldUpdateOperationsInput | string
    termsOfService?: StringFieldUpdateOperationsInput | string
    privacyPolicy?: StringFieldUpdateOperationsInput | string
  }

  export type CcisUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    presentation?: StringFieldUpdateOperationsInput | string
    termsOfService?: StringFieldUpdateOperationsInput | string
    privacyPolicy?: StringFieldUpdateOperationsInput | string
  }

  export type CcisCreateManyInput = {
    id?: string
    presentation: string
    termsOfService: string
    privacyPolicy: string
  }

  export type CcisUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    presentation?: StringFieldUpdateOperationsInput | string
    termsOfService?: StringFieldUpdateOperationsInput | string
    privacyPolicy?: StringFieldUpdateOperationsInput | string
  }

  export type CcisUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    presentation?: StringFieldUpdateOperationsInput | string
    termsOfService?: StringFieldUpdateOperationsInput | string
    privacyPolicy?: StringFieldUpdateOperationsInput | string
  }

  export type TurnoverCreateInput = {
    id?: string
    name: string
    companies?: CompanyCreateNestedManyWithoutTurnoverInput
  }

  export type TurnoverUncheckedCreateInput = {
    id?: string
    name: string
    companies?: CompanyUncheckedCreateNestedManyWithoutTurnoverInput
  }

  export type TurnoverUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUpdateManyWithoutTurnoverNestedInput
  }

  export type TurnoverUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUncheckedUpdateManyWithoutTurnoverNestedInput
  }

  export type TurnoverCreateManyInput = {
    id?: string
    name: string
  }

  export type TurnoverUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type TurnoverUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type NEmployeesCreateInput = {
    id?: string
    name: string
    companies?: CompanyCreateNestedManyWithoutNEmployeesInput
  }

  export type NEmployeesUncheckedCreateInput = {
    id?: string
    name: string
    companies?: CompanyUncheckedCreateNestedManyWithoutNEmployeesInput
  }

  export type NEmployeesUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUpdateManyWithoutNEmployeesNestedInput
  }

  export type NEmployeesUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUncheckedUpdateManyWithoutNEmployeesNestedInput
  }

  export type NEmployeesCreateManyInput = {
    id?: string
    name: string
  }

  export type NEmployeesUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type NEmployeesUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type CityCreateInput = {
    id?: string
    name: string
    users?: UserCreateNestedManyWithoutCityInput
    companies?: CompanyCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateInput = {
    id?: string
    name: string
    users?: UserUncheckedCreateNestedManyWithoutCityInput
    companies?: CompanyUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUpdateManyWithoutCityNestedInput
    companies?: CompanyUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUncheckedUpdateManyWithoutCityNestedInput
    companies?: CompanyUncheckedUpdateManyWithoutCityNestedInput
  }

  export type CityCreateManyInput = {
    id?: string
    name: string
  }

  export type CityUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type CityUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type PositionCreateInput = {
    id?: string
    name: string
    users?: UserCreateNestedManyWithoutPositionInput
    companies?: CompanyCreateNestedManyWithoutContactPositionInput
    electedMembers?: ElectedMemberCreateNestedManyWithoutPositionInput
  }

  export type PositionUncheckedCreateInput = {
    id?: string
    name: string
    users?: UserUncheckedCreateNestedManyWithoutPositionInput
    companies?: CompanyUncheckedCreateNestedManyWithoutContactPositionInput
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutPositionInput
  }

  export type PositionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUpdateManyWithoutPositionNestedInput
    companies?: CompanyUpdateManyWithoutContactPositionNestedInput
    electedMembers?: ElectedMemberUpdateManyWithoutPositionNestedInput
  }

  export type PositionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUncheckedUpdateManyWithoutPositionNestedInput
    companies?: CompanyUncheckedUpdateManyWithoutContactPositionNestedInput
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutPositionNestedInput
  }

  export type PositionCreateManyInput = {
    id?: string
    name: string
  }

  export type PositionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type PositionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ActivityFamilyCreateInput = {
    id?: string
    name: string
    activities?: ActivityCreateNestedManyWithoutActivityFamilyInput
    electedMembers?: ElectedMemberCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyUncheckedCreateInput = {
    id?: string
    name: string
    activities?: ActivityUncheckedCreateNestedManyWithoutActivityFamilyInput
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: ActivityUpdateManyWithoutActivityFamilyNestedInput
    electedMembers?: ElectedMemberUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ActivityFamilyUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: ActivityUncheckedUpdateManyWithoutActivityFamilyNestedInput
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ActivityFamilyCreateManyInput = {
    id?: string
    name: string
  }

  export type ActivityFamilyUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ActivityFamilyUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ActivityCreateInput = {
    id?: string
    name: string
    activityFamily: ActivityFamilyCreateNestedOneWithoutActivitiesInput
    electedMembers?: ElectedMemberCreateNestedManyWithoutActivityInput
  }

  export type ActivityUncheckedCreateInput = {
    id?: string
    name: string
    activityFamilyId: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutActivityInput
  }

  export type ActivityUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutActivitiesNestedInput
    electedMembers?: ElectedMemberUpdateManyWithoutActivityNestedInput
  }

  export type ActivityUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutActivityNestedInput
  }

  export type ActivityCreateManyInput = {
    id?: string
    name: string
    activityFamilyId: string
  }

  export type ActivityUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ActivityUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertiseAreaCreateInput = {
    id?: string
    name: string
  }

  export type ExpertiseAreaUncheckedCreateInput = {
    id?: string
    name: string
  }

  export type ExpertiseAreaUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertiseAreaUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertiseAreaCreateManyInput = {
    id?: string
    name: string
  }

  export type ExpertiseAreaUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ExpertiseAreaUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type InterestAreaCreateInput = {
    id?: string
    name: string
  }

  export type InterestAreaUncheckedCreateInput = {
    id?: string
    name: string
  }

  export type InterestAreaUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type InterestAreaUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type InterestAreaCreateManyInput = {
    id?: string
    name: string
  }

  export type InterestAreaUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type InterestAreaUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ProvinceCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutProvinceInput
    user?: UserCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceUncheckedCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutProvinceInput
    user?: UserUncheckedCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutProvinceNestedInput
    user?: UserUpdateManyWithoutProvinceNestedInput
  }

  export type ProvinceUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutProvinceNestedInput
    user?: UserUncheckedUpdateManyWithoutProvinceNestedInput
  }

  export type ProvinceCreateManyInput = {
    id?: string
    name: string
  }

  export type ProvinceUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ProvinceUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type CategoryCreateInput = {
    id?: string
    name: string
    nameAr: string
    editions?: EditionCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateInput = {
    id?: string
    name: string
    nameAr: string
    editions?: EditionUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
    editions?: EditionUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
    editions?: EditionUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryCreateManyInput = {
    id?: string
    name: string
    nameAr: string
  }

  export type CategoryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
  }

  export type CategoryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
  }

  export type CommissionCreateInput = {
    id?: string
    name: string
    description: string
  }

  export type CommissionUncheckedCreateInput = {
    id?: string
    name: string
    description: string
  }

  export type CommissionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type CommissionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type CommissionCreateManyInput = {
    id?: string
    name: string
    description: string
  }

  export type CommissionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type CommissionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type MandateCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutMandateInput
    user?: UserCreateNestedManyWithoutMandateInput
  }

  export type MandateUncheckedCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutMandateInput
    user?: UserUncheckedCreateNestedManyWithoutMandateInput
  }

  export type MandateUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutMandateNestedInput
    user?: UserUpdateManyWithoutMandateNestedInput
  }

  export type MandateUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutMandateNestedInput
    user?: UserUncheckedUpdateManyWithoutMandateNestedInput
  }

  export type MandateCreateManyInput = {
    id?: string
    name: string
  }

  export type MandateUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type MandateUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type CollegeCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutCollegeInput
    user?: UserCreateNestedManyWithoutCollegeInput
  }

  export type CollegeUncheckedCreateInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutCollegeInput
    user?: UserUncheckedCreateNestedManyWithoutCollegeInput
  }

  export type CollegeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutCollegeNestedInput
    user?: UserUpdateManyWithoutCollegeNestedInput
  }

  export type CollegeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutCollegeNestedInput
    user?: UserUncheckedUpdateManyWithoutCollegeNestedInput
  }

  export type CollegeCreateManyInput = {
    id?: string
    name: string
  }

  export type CollegeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type CollegeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberCreateInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberCreateManyInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type UserCreateInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationCreateInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
    user: UserCreateNestedOneWithoutNotificationsInput
  }

  export type NotificationUncheckedCreateInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
    userId: string
  }

  export type NotificationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
    user?: UserUpdateOneRequiredWithoutNotificationsNestedInput
  }

  export type NotificationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type NotificationCreateManyInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
    userId: string
  }

  export type NotificationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type CompanyCreateInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutCompaniesInput
    contactPosition?: PositionCreateNestedOneWithoutCompaniesInput
    turnover?: TurnoverCreateNestedOneWithoutCompaniesInput
    nEmployees?: NEmployeesCreateNestedOneWithoutCompaniesInput
    users?: UserCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUncheckedCreateInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCompaniesNestedInput
    contactPosition?: PositionUpdateOneWithoutCompaniesNestedInput
    turnover?: TurnoverUpdateOneWithoutCompaniesNestedInput
    nEmployees?: NEmployeesUpdateOneWithoutCompaniesNestedInput
    users?: UserUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyCreateManyInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type CompanyUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CompanyUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionCreateInput = {
    id?: string
    accepted?: boolean
    createdAt?: Date | string
    sender: UserCreateNestedOneWithoutConnectionsSentInput
    receiver: UserCreateNestedOneWithoutConnectionsReceivedInput
  }

  export type ConnectionUncheckedCreateInput = {
    id?: string
    senderId: string
    receiverId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type ConnectionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sender?: UserUpdateOneRequiredWithoutConnectionsSentNestedInput
    receiver?: UserUpdateOneRequiredWithoutConnectionsReceivedNestedInput
  }

  export type ConnectionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionCreateManyInput = {
    id?: string
    senderId: string
    receiverId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type ConnectionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageCreateInput = {
    id?: string
    message: string
    read?: boolean
    createdAt?: Date | string
    sender: UserCreateNestedOneWithoutMessagesSentInput
    receiver: UserCreateNestedOneWithoutMessagesReceivedInput
  }

  export type MessageUncheckedCreateInput = {
    id?: string
    senderId: string
    receiverId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type MessageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sender?: UserUpdateOneRequiredWithoutMessagesSentNestedInput
    receiver?: UserUpdateOneRequiredWithoutMessagesReceivedNestedInput
  }

  export type MessageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageCreateManyInput = {
    id?: string
    senderId: string
    receiverId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type MessageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityCreateInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    creator: UserCreateNestedOneWithoutOpportunitiesInput
    likes?: OpportunityLikeCreateNestedManyWithoutOpportunityInput
    comments?: OpportunityCommentCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityUncheckedCreateInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    creatorId: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    likes?: OpportunityLikeUncheckedCreateNestedManyWithoutOpportunityInput
    comments?: OpportunityCommentUncheckedCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    creator?: UserUpdateOneRequiredWithoutOpportunitiesNestedInput
    likes?: OpportunityLikeUpdateManyWithoutOpportunityNestedInput
    comments?: OpportunityCommentUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    creatorId?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    likes?: OpportunityLikeUncheckedUpdateManyWithoutOpportunityNestedInput
    comments?: OpportunityCommentUncheckedUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityCreateManyInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    creatorId: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
  }

  export type OpportunityUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    creatorId?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityLikeCreateInput = {
    id?: string
    user: UserCreateNestedOneWithoutOpportunityLikesInput
    opportunity: OpportunityCreateNestedOneWithoutLikesInput
  }

  export type OpportunityLikeUncheckedCreateInput = {
    id?: string
    userId: string
    opportunityId: string
  }

  export type OpportunityLikeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutOpportunityLikesNestedInput
    opportunity?: OpportunityUpdateOneRequiredWithoutLikesNestedInput
  }

  export type OpportunityLikeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityLikeCreateManyInput = {
    id?: string
    userId: string
    opportunityId: string
  }

  export type OpportunityLikeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityLikeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityCommentCreateInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutOpportunityCommentsInput
    opportunity: OpportunityCreateNestedOneWithoutCommentsInput
  }

  export type OpportunityCommentUncheckedCreateInput = {
    id?: string
    content: string
    userId: string
    opportunityId: string
    createdAt?: Date | string
  }

  export type OpportunityCommentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutOpportunityCommentsNestedInput
    opportunity?: OpportunityUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type OpportunityCommentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityCommentCreateManyInput = {
    id?: string
    content: string
    userId: string
    opportunityId: string
    createdAt?: Date | string
  }

  export type OpportunityCommentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityCommentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCreateInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    likes?: EventLikeCreateNestedManyWithoutEventInput
    comments?: EventCommentCreateNestedManyWithoutEventInput
  }

  export type EventUncheckedCreateInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    likes?: EventLikeUncheckedCreateNestedManyWithoutEventInput
    comments?: EventCommentUncheckedCreateNestedManyWithoutEventInput
  }

  export type EventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    likes?: EventLikeUpdateManyWithoutEventNestedInput
    comments?: EventCommentUpdateManyWithoutEventNestedInput
  }

  export type EventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    likes?: EventLikeUncheckedUpdateManyWithoutEventNestedInput
    comments?: EventCommentUncheckedUpdateManyWithoutEventNestedInput
  }

  export type EventCreateManyInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
  }

  export type EventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
  }

  export type EventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
  }

  export type EventLikeCreateInput = {
    id?: string
    user: UserCreateNestedOneWithoutEventLikesInput
    event: EventCreateNestedOneWithoutLikesInput
  }

  export type EventLikeUncheckedCreateInput = {
    id?: string
    userId: string
    eventId: string
  }

  export type EventLikeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutEventLikesNestedInput
    event?: EventUpdateOneRequiredWithoutLikesNestedInput
  }

  export type EventLikeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
  }

  export type EventLikeCreateManyInput = {
    id?: string
    userId: string
    eventId: string
  }

  export type EventLikeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
  }

  export type EventLikeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
  }

  export type EventCommentCreateInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutEventCommentsInput
    event: EventCreateNestedOneWithoutCommentsInput
  }

  export type EventCommentUncheckedCreateInput = {
    id?: string
    content: string
    userId: string
    eventId: string
    createdAt?: Date | string
  }

  export type EventCommentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutEventCommentsNestedInput
    event?: EventUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type EventCommentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCommentCreateManyInput = {
    id?: string
    content: string
    userId: string
    eventId: string
    createdAt?: Date | string
  }

  export type EventCommentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCommentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeCreateNestedManyWithoutAppointmentInput
    comments?: AppointmentCommentCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeUncheckedCreateNestedManyWithoutAppointmentInput
    comments?: AppointmentCommentUncheckedCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUpdateManyWithoutAppointmentNestedInput
    comments?: AppointmentCommentUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUncheckedUpdateManyWithoutAppointmentNestedInput
    comments?: AppointmentCommentUncheckedUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentCreateManyInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
  }

  export type AppointmentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
  }

  export type AppointmentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
  }

  export type AppointmentLikeCreateInput = {
    id?: string
    user: UserCreateNestedOneWithoutAppointmentLikesInput
    appointment: AppointmentCreateNestedOneWithoutLikesInput
  }

  export type AppointmentLikeUncheckedCreateInput = {
    id?: string
    userId: string
    appointmentId: string
  }

  export type AppointmentLikeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutAppointmentLikesNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutLikesNestedInput
  }

  export type AppointmentLikeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentLikeCreateManyInput = {
    id?: string
    userId: string
    appointmentId: string
  }

  export type AppointmentLikeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentLikeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentCommentCreateInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutAppointmentCommentsInput
    appointment: AppointmentCreateNestedOneWithoutCommentsInput
  }

  export type AppointmentCommentUncheckedCreateInput = {
    id?: string
    content: string
    userId: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentCommentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAppointmentCommentsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type AppointmentCommentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCommentCreateManyInput = {
    id?: string
    content: string
    userId: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentCommentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCommentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationCreateInput = {
    id?: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutAppointmentsRegistrationsInput
    appointment: AppointmentCreateNestedOneWithoutRegistrationsInput
  }

  export type AppointmentRegistrationUncheckedCreateInput = {
    id?: string
    userId: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentRegistrationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAppointmentsRegistrationsNestedInput
    appointment?: AppointmentUpdateOneRequiredWithoutRegistrationsNestedInput
  }

  export type AppointmentRegistrationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationCreateManyInput = {
    id?: string
    userId: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentRegistrationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AlbumCreateInput = {
    id?: string
    title: string
    date: Date | string
    images?: AlbumCreateimagesInput | string[]
  }

  export type AlbumUncheckedCreateInput = {
    id?: string
    title: string
    date: Date | string
    images?: AlbumCreateimagesInput | string[]
  }

  export type AlbumUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    images?: AlbumUpdateimagesInput | string[]
  }

  export type AlbumUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    images?: AlbumUpdateimagesInput | string[]
  }

  export type AlbumCreateManyInput = {
    id?: string
    title: string
    date: Date | string
    images?: AlbumCreateimagesInput | string[]
  }

  export type AlbumUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    images?: AlbumUpdateimagesInput | string[]
  }

  export type AlbumUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    images?: AlbumUpdateimagesInput | string[]
  }

  export type VideoCreateInput = {
    id?: string
    title: string
    date: Date | string
    link: string
  }

  export type VideoUncheckedCreateInput = {
    id?: string
    title: string
    date: Date | string
    link: string
  }

  export type VideoUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type VideoUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type VideoCreateManyInput = {
    id?: string
    title: string
    date: Date | string
    link: string
  }

  export type VideoUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type VideoUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type EditionCreateInput = {
    id?: string
    title: string
    document: string
    image?: string | null
    category: CategoryCreateNestedOneWithoutEditionsInput
  }

  export type EditionUncheckedCreateInput = {
    id?: string
    title: string
    categoryId: string
    document: string
    image?: string | null
  }

  export type EditionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    category?: CategoryUpdateOneRequiredWithoutEditionsNestedInput
  }

  export type EditionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    categoryId?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type EditionCreateManyInput = {
    id?: string
    title: string
    categoryId: string
    document: string
    image?: string | null
  }

  export type EditionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type EditionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    categoryId?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TrainingCreateInput = {
    id?: string
    title: string
    place: string
    date: Date | string
    email: string
    phoneNumber: string
    website: string
    type?: $Enums.TrainingType
    description: string
    document?: string | null
  }

  export type TrainingUncheckedCreateInput = {
    id?: string
    title: string
    place: string
    date: Date | string
    email: string
    phoneNumber: string
    website: string
    type?: $Enums.TrainingType
    description: string
    document?: string | null
  }

  export type TrainingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    type?: EnumTrainingTypeFieldUpdateOperationsInput | $Enums.TrainingType
    description?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TrainingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    type?: EnumTrainingTypeFieldUpdateOperationsInput | $Enums.TrainingType
    description?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TrainingCreateManyInput = {
    id?: string
    title: string
    place: string
    date: Date | string
    email: string
    phoneNumber: string
    website: string
    type?: $Enums.TrainingType
    description: string
    document?: string | null
  }

  export type TrainingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    type?: EnumTrainingTypeFieldUpdateOperationsInput | $Enums.TrainingType
    description?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TrainingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    type?: EnumTrainingTypeFieldUpdateOperationsInput | $Enums.TrainingType
    description?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type FairCreateInput = {
    id?: string
    title: string
    country: string
    place: string
    startDate: Date | string
    endDate: Date | string
    sector: string
    organizer: string
    phoneNumber: string
    fax: string
    email: string
    website: string
  }

  export type FairUncheckedCreateInput = {
    id?: string
    title: string
    country: string
    place: string
    startDate: Date | string
    endDate: Date | string
    sector: string
    organizer: string
    phoneNumber: string
    fax: string
    email: string
    website: string
  }

  export type FairUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    startDate?: DateTimeFieldUpdateOperationsInput | Date | string
    endDate?: DateTimeFieldUpdateOperationsInput | Date | string
    sector?: StringFieldUpdateOperationsInput | string
    organizer?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
  }

  export type FairUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    startDate?: DateTimeFieldUpdateOperationsInput | Date | string
    endDate?: DateTimeFieldUpdateOperationsInput | Date | string
    sector?: StringFieldUpdateOperationsInput | string
    organizer?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
  }

  export type FairCreateManyInput = {
    id?: string
    title: string
    country: string
    place: string
    startDate: Date | string
    endDate: Date | string
    sector: string
    organizer: string
    phoneNumber: string
    fax: string
    email: string
    website: string
  }

  export type FairUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    startDate?: DateTimeFieldUpdateOperationsInput | Date | string
    endDate?: DateTimeFieldUpdateOperationsInput | Date | string
    sector?: StringFieldUpdateOperationsInput | string
    organizer?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
  }

  export type FairUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    place?: StringFieldUpdateOperationsInput | string
    startDate?: DateTimeFieldUpdateOperationsInput | Date | string
    endDate?: DateTimeFieldUpdateOperationsInput | Date | string
    sector?: StringFieldUpdateOperationsInput | string
    organizer?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
  }

  export type BusinessPlanCreateInput = {
    id?: string
    firstName: string
    lastName: string
    nationality: string
    phoneNumber: string
    email: string
    projectIdea: string
    location: string
    educationAndExperience: string
    financingPlan: string
    createdAt?: Date | string
  }

  export type BusinessPlanUncheckedCreateInput = {
    id?: string
    firstName: string
    lastName: string
    nationality: string
    phoneNumber: string
    email: string
    projectIdea: string
    location: string
    educationAndExperience: string
    financingPlan: string
    createdAt?: Date | string
  }

  export type BusinessPlanUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    nationality?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    financingPlan?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BusinessPlanUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    nationality?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    financingPlan?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BusinessPlanCreateManyInput = {
    id?: string
    firstName: string
    lastName: string
    nationality: string
    phoneNumber: string
    email: string
    projectIdea: string
    location: string
    educationAndExperience: string
    financingPlan: string
    createdAt?: Date | string
  }

  export type BusinessPlanUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    nationality?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    financingPlan?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BusinessPlanUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    nationality?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    financingPlan?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MarketResearchCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    address: string
    city: string
    state: string
    zipCode: string
    country: string
    projectIdea: string
    educationAndExperience: string
    createdAt?: Date | string
  }

  export type MarketResearchUncheckedCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    address: string
    city: string
    state: string
    zipCode: string
    country: string
    projectIdea: string
    educationAndExperience: string
    createdAt?: Date | string
  }

  export type MarketResearchUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    city?: StringFieldUpdateOperationsInput | string
    state?: StringFieldUpdateOperationsInput | string
    zipCode?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MarketResearchUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    city?: StringFieldUpdateOperationsInput | string
    state?: StringFieldUpdateOperationsInput | string
    zipCode?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MarketResearchCreateManyInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    address: string
    city: string
    state: string
    zipCode: string
    country: string
    projectIdea: string
    educationAndExperience: string
    createdAt?: Date | string
  }

  export type MarketResearchUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    city?: StringFieldUpdateOperationsInput | string
    state?: StringFieldUpdateOperationsInput | string
    zipCode?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MarketResearchUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    city?: StringFieldUpdateOperationsInput | string
    state?: StringFieldUpdateOperationsInput | string
    zipCode?: StringFieldUpdateOperationsInput | string
    country?: StringFieldUpdateOperationsInput | string
    projectIdea?: StringFieldUpdateOperationsInput | string
    educationAndExperience?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NetworkingCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForNetworking: string
    createdAt?: Date | string
  }

  export type NetworkingUncheckedCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForNetworking: string
    createdAt?: Date | string
  }

  export type NetworkingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForNetworking?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NetworkingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForNetworking?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NetworkingCreateManyInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForNetworking: string
    createdAt?: Date | string
  }

  export type NetworkingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForNetworking?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NetworkingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForNetworking?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SourcingCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    productsToSource: string
    createdAt?: Date | string
  }

  export type SourcingUncheckedCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    productsToSource: string
    createdAt?: Date | string
  }

  export type SourcingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    productsToSource?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SourcingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    productsToSource?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SourcingCreateManyInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    productsToSource: string
    createdAt?: Date | string
  }

  export type SourcingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    productsToSource?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SourcingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    productsToSource?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProspectingCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForProspecting: string
    createdAt?: Date | string
  }

  export type ProspectingUncheckedCreateInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForProspecting: string
    createdAt?: Date | string
  }

  export type ProspectingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForProspecting?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProspectingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForProspecting?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProspectingCreateManyInput = {
    id?: string
    firstName: string
    lastName: string
    phoneNumber: string
    email: string
    activity: string
    needForProspecting: string
    createdAt?: Date | string
  }

  export type ProspectingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForProspecting?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProspectingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    activity?: StringFieldUpdateOperationsInput | string
    needForProspecting?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsLogCreateInput = {
    id?: string
    createdAt?: Date | string
    gateway: string
    senderId: string
    recipient: string
    content: string
    statusCode?: number | null
    statusText?: string | null
    requestUrl?: string | null
    requestBody?: string | null
    responseBody?: string | null
    errorMessage?: string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: string | null
  }

  export type SmsLogUncheckedCreateInput = {
    id?: string
    createdAt?: Date | string
    gateway: string
    senderId: string
    recipient: string
    content: string
    statusCode?: number | null
    statusText?: string | null
    requestUrl?: string | null
    requestBody?: string | null
    responseBody?: string | null
    errorMessage?: string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: string | null
  }

  export type SmsLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    gateway?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    recipient?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    statusCode?: NullableIntFieldUpdateOperationsInput | number | null
    statusText?: NullableStringFieldUpdateOperationsInput | string | null
    requestUrl?: NullableStringFieldUpdateOperationsInput | string | null
    requestBody?: NullableStringFieldUpdateOperationsInput | string | null
    responseBody?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SmsLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    gateway?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    recipient?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    statusCode?: NullableIntFieldUpdateOperationsInput | number | null
    statusText?: NullableStringFieldUpdateOperationsInput | string | null
    requestUrl?: NullableStringFieldUpdateOperationsInput | string | null
    requestBody?: NullableStringFieldUpdateOperationsInput | string | null
    responseBody?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SmsLogCreateManyInput = {
    id?: string
    createdAt?: Date | string
    gateway: string
    senderId: string
    recipient: string
    content: string
    statusCode?: number | null
    statusText?: string | null
    requestUrl?: string | null
    requestBody?: string | null
    responseBody?: string | null
    errorMessage?: string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: string | null
  }

  export type SmsLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    gateway?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    recipient?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    statusCode?: NullableIntFieldUpdateOperationsInput | number | null
    statusText?: NullableStringFieldUpdateOperationsInput | string | null
    requestUrl?: NullableStringFieldUpdateOperationsInput | string | null
    requestBody?: NullableStringFieldUpdateOperationsInput | string | null
    responseBody?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SmsLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    gateway?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    recipient?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    statusCode?: NullableIntFieldUpdateOperationsInput | number | null
    statusText?: NullableStringFieldUpdateOperationsInput | string | null
    requestUrl?: NullableStringFieldUpdateOperationsInput | string | null
    requestBody?: NullableStringFieldUpdateOperationsInput | string | null
    responseBody?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    meta?: NullableJsonNullValueInput | InputJsonValue
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  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 CcisCountOrderByAggregateInput = {
    id?: SortOrder
    presentation?: SortOrder
    termsOfService?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type CcisMaxOrderByAggregateInput = {
    id?: SortOrder
    presentation?: SortOrder
    termsOfService?: SortOrder
    privacyPolicy?: SortOrder
  }

  export type CcisMinOrderByAggregateInput = {
    id?: SortOrder
    presentation?: SortOrder
    termsOfService?: SortOrder
    privacyPolicy?: 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 CompanyListRelationFilter = {
    every?: CompanyWhereInput
    some?: CompanyWhereInput
    none?: CompanyWhereInput
  }

  export type CompanyOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TurnoverCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type TurnoverMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type TurnoverMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type NEmployeesCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type NEmployeesMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type NEmployeesMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type UserListRelationFilter = {
    every?: UserWhereInput
    some?: UserWhereInput
    none?: UserWhereInput
  }

  export type UserOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CityCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type CityMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type CityMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ElectedMemberListRelationFilter = {
    every?: ElectedMemberWhereInput
    some?: ElectedMemberWhereInput
    none?: ElectedMemberWhereInput
  }

  export type ElectedMemberOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PositionCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type PositionMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type PositionMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ActivityListRelationFilter = {
    every?: ActivityWhereInput
    some?: ActivityWhereInput
    none?: ActivityWhereInput
  }

  export type ActivityOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ActivityFamilyCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ActivityFamilyMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ActivityFamilyMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ActivityFamilyRelationFilter = {
    is?: ActivityFamilyWhereInput
    isNot?: ActivityFamilyWhereInput
  }

  export type ActivityCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    activityFamilyId?: SortOrder
  }

  export type ActivityMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    activityFamilyId?: SortOrder
  }

  export type ActivityMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    activityFamilyId?: SortOrder
  }

  export type ExpertiseAreaCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ExpertiseAreaMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ExpertiseAreaMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type InterestAreaCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type InterestAreaMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type InterestAreaMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ProvinceCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ProvinceMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type ProvinceMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type EditionListRelationFilter = {
    every?: EditionWhereInput
    some?: EditionWhereInput
    none?: EditionWhereInput
  }

  export type EditionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CategoryCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    nameAr?: SortOrder
  }

  export type CategoryMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    nameAr?: SortOrder
  }

  export type CategoryMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    nameAr?: SortOrder
  }

  export type CommissionCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
  }

  export type CommissionMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
  }

  export type CommissionMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
  }

  export type MandateCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type MandateMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type MandateMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type CollegeCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type CollegeMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type CollegeMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  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 PositionRelationFilter = {
    is?: PositionWhereInput
    isNot?: PositionWhereInput
  }

  export type ActivityRelationFilter = {
    is?: ActivityWhereInput
    isNot?: ActivityWhereInput
  }

  export type CollegeRelationFilter = {
    is?: CollegeWhereInput
    isNot?: CollegeWhereInput
  }

  export type ProvinceRelationFilter = {
    is?: ProvinceWhereInput
    isNot?: ProvinceWhereInput
  }

  export type MandateRelationFilter = {
    is?: MandateWhereInput
    isNot?: MandateWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type ElectedMemberCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    fullName?: SortOrder
    positionId?: SortOrder
    activityFamilyId?: SortOrder
    activityId?: SortOrder
    phoneNumber?: SortOrder
    gsm?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    commissions?: SortOrder
    details?: SortOrder
  }

  export type ElectedMemberMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    fullName?: SortOrder
    positionId?: SortOrder
    activityFamilyId?: SortOrder
    activityId?: SortOrder
    phoneNumber?: SortOrder
    gsm?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    details?: SortOrder
  }

  export type ElectedMemberMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    fullName?: SortOrder
    positionId?: SortOrder
    activityFamilyId?: SortOrder
    activityId?: SortOrder
    phoneNumber?: SortOrder
    gsm?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    details?: SortOrder
  }

  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 EnumCivilityFilter<$PrismaModel = never> = {
    equals?: $Enums.Civility | EnumCivilityFieldRefInput<$PrismaModel>
    in?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    notIn?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    not?: NestedEnumCivilityFilter<$PrismaModel> | $Enums.Civility
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type EnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  export type EnumPermissionNullableListFilter<$PrismaModel = never> = {
    equals?: $Enums.Permission[] | ListEnumPermissionFieldRefInput<$PrismaModel> | null
    has?: $Enums.Permission | EnumPermissionFieldRefInput<$PrismaModel> | null
    hasEvery?: $Enums.Permission[] | ListEnumPermissionFieldRefInput<$PrismaModel>
    hasSome?: $Enums.Permission[] | ListEnumPermissionFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }

  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 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 CityNullableRelationFilter = {
    is?: CityWhereInput | null
    isNot?: CityWhereInput | null
  }

  export type PositionNullableRelationFilter = {
    is?: PositionWhereInput | null
    isNot?: PositionWhereInput | null
  }

  export type CompanyNullableRelationFilter = {
    is?: CompanyWhereInput | null
    isNot?: CompanyWhereInput | null
  }

  export type CollegeNullableRelationFilter = {
    is?: CollegeWhereInput | null
    isNot?: CollegeWhereInput | null
  }

  export type ProvinceNullableRelationFilter = {
    is?: ProvinceWhereInput | null
    isNot?: ProvinceWhereInput | null
  }

  export type MandateNullableRelationFilter = {
    is?: MandateWhereInput | null
    isNot?: MandateWhereInput | null
  }

  export type ConnectionListRelationFilter = {
    every?: ConnectionWhereInput
    some?: ConnectionWhereInput
    none?: ConnectionWhereInput
  }

  export type MessageListRelationFilter = {
    every?: MessageWhereInput
    some?: MessageWhereInput
    none?: MessageWhereInput
  }

  export type OpportunityListRelationFilter = {
    every?: OpportunityWhereInput
    some?: OpportunityWhereInput
    none?: OpportunityWhereInput
  }

  export type OpportunityLikeListRelationFilter = {
    every?: OpportunityLikeWhereInput
    some?: OpportunityLikeWhereInput
    none?: OpportunityLikeWhereInput
  }

  export type OpportunityCommentListRelationFilter = {
    every?: OpportunityCommentWhereInput
    some?: OpportunityCommentWhereInput
    none?: OpportunityCommentWhereInput
  }

  export type EventLikeListRelationFilter = {
    every?: EventLikeWhereInput
    some?: EventLikeWhereInput
    none?: EventLikeWhereInput
  }

  export type EventCommentListRelationFilter = {
    every?: EventCommentWhereInput
    some?: EventCommentWhereInput
    none?: EventCommentWhereInput
  }

  export type AppointmentLikeListRelationFilter = {
    every?: AppointmentLikeWhereInput
    some?: AppointmentLikeWhereInput
    none?: AppointmentLikeWhereInput
  }

  export type AppointmentCommentListRelationFilter = {
    every?: AppointmentCommentWhereInput
    some?: AppointmentCommentWhereInput
    none?: AppointmentCommentWhereInput
  }

  export type NotificationListRelationFilter = {
    every?: NotificationWhereInput
    some?: NotificationWhereInput
    none?: NotificationWhereInput
  }

  export type AppointmentRegistrationListRelationFilter = {
    every?: AppointmentRegistrationWhereInput
    some?: AppointmentRegistrationWhereInput
    none?: AppointmentRegistrationWhereInput
  }

  export type ConnectionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MessageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type OpportunityOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type OpportunityLikeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type OpportunityCommentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type EventLikeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type EventCommentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AppointmentLikeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AppointmentCommentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NotificationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AppointmentRegistrationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    civility?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    password?: SortOrder
    cityId?: SortOrder
    positionId?: SortOrder
    phoneNumber?: SortOrder
    expertiseAreas?: SortOrder
    interestAreas?: SortOrder
    bio?: SortOrder
    companyId?: SortOrder
    department?: SortOrder
    service?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    commissions?: SortOrder
    details?: SortOrder
    active?: SortOrder
    member?: SortOrder
    role?: SortOrder
    permissions?: SortOrder
    resetPasswordCode?: SortOrder
    resetPasswordAt?: SortOrder
    loggedInAt?: SortOrder
    createdAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    civility?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    password?: SortOrder
    cityId?: SortOrder
    positionId?: SortOrder
    phoneNumber?: SortOrder
    bio?: SortOrder
    companyId?: SortOrder
    department?: SortOrder
    service?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    details?: SortOrder
    active?: SortOrder
    member?: SortOrder
    role?: SortOrder
    resetPasswordCode?: SortOrder
    resetPasswordAt?: SortOrder
    loggedInAt?: SortOrder
    createdAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    civility?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    email?: SortOrder
    password?: SortOrder
    cityId?: SortOrder
    positionId?: SortOrder
    phoneNumber?: SortOrder
    bio?: SortOrder
    companyId?: SortOrder
    department?: SortOrder
    service?: SortOrder
    adresse?: SortOrder
    collegeId?: SortOrder
    provinceId?: SortOrder
    mandateId?: SortOrder
    details?: SortOrder
    active?: SortOrder
    member?: SortOrder
    role?: SortOrder
    resetPasswordCode?: SortOrder
    resetPasswordAt?: SortOrder
    loggedInAt?: SortOrder
    createdAt?: SortOrder
  }

  export type EnumCivilityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Civility | EnumCivilityFieldRefInput<$PrismaModel>
    in?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    notIn?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    not?: NestedEnumCivilityWithAggregatesFilter<$PrismaModel> | $Enums.Civility
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCivilityFilter<$PrismaModel>
    _max?: NestedEnumCivilityFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type EnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$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 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 EnumSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.Source | EnumSourceFieldRefInput<$PrismaModel>
    in?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumSourceFilter<$PrismaModel> | $Enums.Source
  }

  export type UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type NotificationCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    content?: SortOrder
    source?: SortOrder
    createdAt?: SortOrder
    isRead?: SortOrder
    userId?: SortOrder
  }

  export type NotificationMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    content?: SortOrder
    source?: SortOrder
    createdAt?: SortOrder
    isRead?: SortOrder
    userId?: SortOrder
  }

  export type NotificationMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    content?: SortOrder
    source?: SortOrder
    createdAt?: SortOrder
    isRead?: SortOrder
    userId?: SortOrder
  }

  export type EnumSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Source | EnumSourceFieldRefInput<$PrismaModel>
    in?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumSourceWithAggregatesFilter<$PrismaModel> | $Enums.Source
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSourceFilter<$PrismaModel>
    _max?: NestedEnumSourceFilter<$PrismaModel>
  }

  export type EnumLegalFormFilter<$PrismaModel = never> = {
    equals?: $Enums.LegalForm | EnumLegalFormFieldRefInput<$PrismaModel>
    in?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    notIn?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    not?: NestedEnumLegalFormFilter<$PrismaModel> | $Enums.LegalForm
  }

  export type FloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type TurnoverNullableRelationFilter = {
    is?: TurnoverWhereInput | null
    isNot?: TurnoverWhereInput | null
  }

  export type NEmployeesNullableRelationFilter = {
    is?: NEmployeesWhereInput | null
    isNot?: NEmployeesWhereInput | null
  }

  export type CompanyCountOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
    name?: SortOrder
    legalForm?: SortOrder
    cityId?: SortOrder
    address?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    linkedin?: SortOrder
    facebook?: SortOrder
    contactFirstName?: SortOrder
    contactLastName?: SortOrder
    contactEmail?: SortOrder
    contactPositionId?: SortOrder
    contactLinkedin?: SortOrder
    contactFacebook?: SortOrder
    businessLicense?: SortOrder
    numRC?: SortOrder
    numICE?: SortOrder
    capital?: SortOrder
    turnoverId?: SortOrder
    nEmployeesId?: SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    importCountries?: SortOrder
    exportCountries?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    partner?: SortOrder
    contributor?: SortOrder
    createdAt?: SortOrder
  }

  export type CompanyAvgOrderByAggregateInput = {
    capital?: SortOrder
  }

  export type CompanyMaxOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
    name?: SortOrder
    legalForm?: SortOrder
    cityId?: SortOrder
    address?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    linkedin?: SortOrder
    facebook?: SortOrder
    contactFirstName?: SortOrder
    contactLastName?: SortOrder
    contactEmail?: SortOrder
    contactPositionId?: SortOrder
    contactLinkedin?: SortOrder
    contactFacebook?: SortOrder
    businessLicense?: SortOrder
    numRC?: SortOrder
    numICE?: SortOrder
    capital?: SortOrder
    turnoverId?: SortOrder
    nEmployeesId?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    partner?: SortOrder
    contributor?: SortOrder
    createdAt?: SortOrder
  }

  export type CompanyMinOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
    name?: SortOrder
    legalForm?: SortOrder
    cityId?: SortOrder
    address?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
    linkedin?: SortOrder
    facebook?: SortOrder
    contactFirstName?: SortOrder
    contactLastName?: SortOrder
    contactEmail?: SortOrder
    contactPositionId?: SortOrder
    contactLinkedin?: SortOrder
    contactFacebook?: SortOrder
    businessLicense?: SortOrder
    numRC?: SortOrder
    numICE?: SortOrder
    capital?: SortOrder
    turnoverId?: SortOrder
    nEmployeesId?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    partner?: SortOrder
    contributor?: SortOrder
    createdAt?: SortOrder
  }

  export type CompanySumOrderByAggregateInput = {
    capital?: SortOrder
  }

  export type EnumLegalFormWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LegalForm | EnumLegalFormFieldRefInput<$PrismaModel>
    in?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    notIn?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    not?: NestedEnumLegalFormWithAggregatesFilter<$PrismaModel> | $Enums.LegalForm
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLegalFormFilter<$PrismaModel>
    _max?: NestedEnumLegalFormFilter<$PrismaModel>
  }

  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type ConnectionCountOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    accepted?: SortOrder
    createdAt?: SortOrder
  }

  export type ConnectionMaxOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    accepted?: SortOrder
    createdAt?: SortOrder
  }

  export type ConnectionMinOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    accepted?: SortOrder
    createdAt?: SortOrder
  }

  export type MessageCountOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    message?: SortOrder
    read?: SortOrder
    createdAt?: SortOrder
  }

  export type MessageMaxOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    message?: SortOrder
    read?: SortOrder
    createdAt?: SortOrder
  }

  export type MessageMinOrderByAggregateInput = {
    id?: SortOrder
    senderId?: SortOrder
    receiverId?: SortOrder
    message?: SortOrder
    read?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    companyName?: SortOrder
    activitiesFamilies?: SortOrder
    activities?: SortOrder
    country?: SortOrder
    address?: SortOrder
    requirements?: SortOrder
    contactEmail?: SortOrder
    contactPhoneNumber?: SortOrder
    creatorId?: SortOrder
    document?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    validityDate?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    companyName?: SortOrder
    country?: SortOrder
    address?: SortOrder
    requirements?: SortOrder
    contactEmail?: SortOrder
    contactPhoneNumber?: SortOrder
    creatorId?: SortOrder
    document?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    validityDate?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    companyName?: SortOrder
    country?: SortOrder
    address?: SortOrder
    requirements?: SortOrder
    contactEmail?: SortOrder
    contactPhoneNumber?: SortOrder
    creatorId?: SortOrder
    document?: SortOrder
    verified?: SortOrder
    active?: SortOrder
    validityDate?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityRelationFilter = {
    is?: OpportunityWhereInput
    isNot?: OpportunityWhereInput
  }

  export type OpportunityLikeCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
  }

  export type OpportunityLikeMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
  }

  export type OpportunityLikeMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
  }

  export type OpportunityCommentCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityCommentMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    createdAt?: SortOrder
  }

  export type OpportunityCommentMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    opportunityId?: SortOrder
    createdAt?: SortOrder
  }

  export type EventCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    active?: SortOrder
    images?: SortOrder
  }

  export type EventMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    active?: SortOrder
  }

  export type EventMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    active?: SortOrder
  }

  export type EventRelationFilter = {
    is?: EventWhereInput
    isNot?: EventWhereInput
  }

  export type EventLikeCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
  }

  export type EventLikeMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
  }

  export type EventLikeMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
  }

  export type EventCommentCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    createdAt?: SortOrder
  }

  export type EventCommentMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    createdAt?: SortOrder
  }

  export type EventCommentMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    eventId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    time?: SortOrder
    activationDate?: SortOrder
    address?: SortOrder
    active?: SortOrder
    images?: SortOrder
  }

  export type AppointmentMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    time?: SortOrder
    activationDate?: SortOrder
    address?: SortOrder
    active?: SortOrder
  }

  export type AppointmentMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    briefDescription?: SortOrder
    description?: SortOrder
    date?: SortOrder
    time?: SortOrder
    activationDate?: SortOrder
    address?: SortOrder
    active?: SortOrder
  }

  export type AppointmentRelationFilter = {
    is?: AppointmentWhereInput
    isNot?: AppointmentWhereInput
  }

  export type AppointmentLikeCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
  }

  export type AppointmentLikeMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
  }

  export type AppointmentLikeMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
  }

  export type AppointmentCommentCountOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentCommentMaxOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentCommentMinOrderByAggregateInput = {
    id?: SortOrder
    content?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentRegistrationCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentRegistrationMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AppointmentRegistrationMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    appointmentId?: SortOrder
    createdAt?: SortOrder
  }

  export type AlbumCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    images?: SortOrder
  }

  export type AlbumMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
  }

  export type AlbumMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
  }

  export type VideoCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    link?: SortOrder
  }

  export type VideoMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    link?: SortOrder
  }

  export type VideoMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    date?: SortOrder
    link?: SortOrder
  }

  export type CategoryRelationFilter = {
    is?: CategoryWhereInput
    isNot?: CategoryWhereInput
  }

  export type EditionCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    categoryId?: SortOrder
    document?: SortOrder
    image?: SortOrder
  }

  export type EditionMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    categoryId?: SortOrder
    document?: SortOrder
    image?: SortOrder
  }

  export type EditionMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    categoryId?: SortOrder
    document?: SortOrder
    image?: SortOrder
  }

  export type EnumTrainingTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.TrainingType | EnumTrainingTypeFieldRefInput<$PrismaModel>
    in?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTrainingTypeFilter<$PrismaModel> | $Enums.TrainingType
  }

  export type TrainingCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    place?: SortOrder
    date?: SortOrder
    email?: SortOrder
    phoneNumber?: SortOrder
    website?: SortOrder
    type?: SortOrder
    description?: SortOrder
    document?: SortOrder
  }

  export type TrainingMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    place?: SortOrder
    date?: SortOrder
    email?: SortOrder
    phoneNumber?: SortOrder
    website?: SortOrder
    type?: SortOrder
    description?: SortOrder
    document?: SortOrder
  }

  export type TrainingMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    place?: SortOrder
    date?: SortOrder
    email?: SortOrder
    phoneNumber?: SortOrder
    website?: SortOrder
    type?: SortOrder
    description?: SortOrder
    document?: SortOrder
  }

  export type EnumTrainingTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.TrainingType | EnumTrainingTypeFieldRefInput<$PrismaModel>
    in?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTrainingTypeWithAggregatesFilter<$PrismaModel> | $Enums.TrainingType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTrainingTypeFilter<$PrismaModel>
    _max?: NestedEnumTrainingTypeFilter<$PrismaModel>
  }

  export type FairCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    country?: SortOrder
    place?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
    sector?: SortOrder
    organizer?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
  }

  export type FairMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    country?: SortOrder
    place?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
    sector?: SortOrder
    organizer?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
  }

  export type FairMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    country?: SortOrder
    place?: SortOrder
    startDate?: SortOrder
    endDate?: SortOrder
    sector?: SortOrder
    organizer?: SortOrder
    phoneNumber?: SortOrder
    fax?: SortOrder
    email?: SortOrder
    website?: SortOrder
  }

  export type BusinessPlanCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    nationality?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    projectIdea?: SortOrder
    location?: SortOrder
    educationAndExperience?: SortOrder
    financingPlan?: SortOrder
    createdAt?: SortOrder
  }

  export type BusinessPlanMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    nationality?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    projectIdea?: SortOrder
    location?: SortOrder
    educationAndExperience?: SortOrder
    financingPlan?: SortOrder
    createdAt?: SortOrder
  }

  export type BusinessPlanMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    nationality?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    projectIdea?: SortOrder
    location?: SortOrder
    educationAndExperience?: SortOrder
    financingPlan?: SortOrder
    createdAt?: SortOrder
  }

  export type MarketResearchCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
    country?: SortOrder
    projectIdea?: SortOrder
    educationAndExperience?: SortOrder
    createdAt?: SortOrder
  }

  export type MarketResearchMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
    country?: SortOrder
    projectIdea?: SortOrder
    educationAndExperience?: SortOrder
    createdAt?: SortOrder
  }

  export type MarketResearchMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    address?: SortOrder
    city?: SortOrder
    state?: SortOrder
    zipCode?: SortOrder
    country?: SortOrder
    projectIdea?: SortOrder
    educationAndExperience?: SortOrder
    createdAt?: SortOrder
  }

  export type NetworkingCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForNetworking?: SortOrder
    createdAt?: SortOrder
  }

  export type NetworkingMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForNetworking?: SortOrder
    createdAt?: SortOrder
  }

  export type NetworkingMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForNetworking?: SortOrder
    createdAt?: SortOrder
  }

  export type SourcingCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    productsToSource?: SortOrder
    createdAt?: SortOrder
  }

  export type SourcingMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    productsToSource?: SortOrder
    createdAt?: SortOrder
  }

  export type SourcingMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    productsToSource?: SortOrder
    createdAt?: SortOrder
  }

  export type ProspectingCountOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForProspecting?: SortOrder
    createdAt?: SortOrder
  }

  export type ProspectingMaxOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForProspecting?: SortOrder
    createdAt?: SortOrder
  }

  export type ProspectingMinOrderByAggregateInput = {
    id?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    phoneNumber?: SortOrder
    email?: SortOrder
    activity?: SortOrder
    needForProspecting?: SortOrder
    createdAt?: SortOrder
  }

  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 JsonNullableFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type SmsLogCountOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    gateway?: SortOrder
    senderId?: SortOrder
    recipient?: SortOrder
    content?: SortOrder
    statusCode?: SortOrder
    statusText?: SortOrder
    requestUrl?: SortOrder
    requestBody?: SortOrder
    responseBody?: SortOrder
    errorMessage?: SortOrder
    meta?: SortOrder
    userId?: SortOrder
  }

  export type SmsLogAvgOrderByAggregateInput = {
    statusCode?: SortOrder
  }

  export type SmsLogMaxOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    gateway?: SortOrder
    senderId?: SortOrder
    recipient?: SortOrder
    content?: SortOrder
    statusCode?: SortOrder
    statusText?: SortOrder
    requestUrl?: SortOrder
    requestBody?: SortOrder
    responseBody?: SortOrder
    errorMessage?: SortOrder
    userId?: SortOrder
  }

  export type SmsLogMinOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
    gateway?: SortOrder
    senderId?: SortOrder
    recipient?: SortOrder
    content?: SortOrder
    statusCode?: SortOrder
    statusText?: SortOrder
    requestUrl?: SortOrder
    requestBody?: SortOrder
    responseBody?: SortOrder
    errorMessage?: SortOrder
    userId?: SortOrder
  }

  export type SmsLogSumOrderByAggregateInput = {
    statusCode?: 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 JsonNullableWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type CompanyCreateNestedManyWithoutTurnoverInput = {
    create?: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput> | CompanyCreateWithoutTurnoverInput[] | CompanyUncheckedCreateWithoutTurnoverInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutTurnoverInput | CompanyCreateOrConnectWithoutTurnoverInput[]
    createMany?: CompanyCreateManyTurnoverInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type CompanyUncheckedCreateNestedManyWithoutTurnoverInput = {
    create?: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput> | CompanyCreateWithoutTurnoverInput[] | CompanyUncheckedCreateWithoutTurnoverInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutTurnoverInput | CompanyCreateOrConnectWithoutTurnoverInput[]
    createMany?: CompanyCreateManyTurnoverInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type CompanyUpdateManyWithoutTurnoverNestedInput = {
    create?: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput> | CompanyCreateWithoutTurnoverInput[] | CompanyUncheckedCreateWithoutTurnoverInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutTurnoverInput | CompanyCreateOrConnectWithoutTurnoverInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutTurnoverInput | CompanyUpsertWithWhereUniqueWithoutTurnoverInput[]
    createMany?: CompanyCreateManyTurnoverInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutTurnoverInput | CompanyUpdateWithWhereUniqueWithoutTurnoverInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutTurnoverInput | CompanyUpdateManyWithWhereWithoutTurnoverInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type CompanyUncheckedUpdateManyWithoutTurnoverNestedInput = {
    create?: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput> | CompanyCreateWithoutTurnoverInput[] | CompanyUncheckedCreateWithoutTurnoverInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutTurnoverInput | CompanyCreateOrConnectWithoutTurnoverInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutTurnoverInput | CompanyUpsertWithWhereUniqueWithoutTurnoverInput[]
    createMany?: CompanyCreateManyTurnoverInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutTurnoverInput | CompanyUpdateWithWhereUniqueWithoutTurnoverInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutTurnoverInput | CompanyUpdateManyWithWhereWithoutTurnoverInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type CompanyCreateNestedManyWithoutNEmployeesInput = {
    create?: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput> | CompanyCreateWithoutNEmployeesInput[] | CompanyUncheckedCreateWithoutNEmployeesInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutNEmployeesInput | CompanyCreateOrConnectWithoutNEmployeesInput[]
    createMany?: CompanyCreateManyNEmployeesInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type CompanyUncheckedCreateNestedManyWithoutNEmployeesInput = {
    create?: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput> | CompanyCreateWithoutNEmployeesInput[] | CompanyUncheckedCreateWithoutNEmployeesInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutNEmployeesInput | CompanyCreateOrConnectWithoutNEmployeesInput[]
    createMany?: CompanyCreateManyNEmployeesInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type CompanyUpdateManyWithoutNEmployeesNestedInput = {
    create?: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput> | CompanyCreateWithoutNEmployeesInput[] | CompanyUncheckedCreateWithoutNEmployeesInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutNEmployeesInput | CompanyCreateOrConnectWithoutNEmployeesInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutNEmployeesInput | CompanyUpsertWithWhereUniqueWithoutNEmployeesInput[]
    createMany?: CompanyCreateManyNEmployeesInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutNEmployeesInput | CompanyUpdateWithWhereUniqueWithoutNEmployeesInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutNEmployeesInput | CompanyUpdateManyWithWhereWithoutNEmployeesInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type CompanyUncheckedUpdateManyWithoutNEmployeesNestedInput = {
    create?: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput> | CompanyCreateWithoutNEmployeesInput[] | CompanyUncheckedCreateWithoutNEmployeesInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutNEmployeesInput | CompanyCreateOrConnectWithoutNEmployeesInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutNEmployeesInput | CompanyUpsertWithWhereUniqueWithoutNEmployeesInput[]
    createMany?: CompanyCreateManyNEmployeesInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutNEmployeesInput | CompanyUpdateWithWhereUniqueWithoutNEmployeesInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutNEmployeesInput | CompanyUpdateManyWithWhereWithoutNEmployeesInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type UserCreateNestedManyWithoutCityInput = {
    create?: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput> | UserCreateWithoutCityInput[] | UserUncheckedCreateWithoutCityInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCityInput | UserCreateOrConnectWithoutCityInput[]
    createMany?: UserCreateManyCityInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type CompanyCreateNestedManyWithoutCityInput = {
    create?: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput> | CompanyCreateWithoutCityInput[] | CompanyUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutCityInput | CompanyCreateOrConnectWithoutCityInput[]
    createMany?: CompanyCreateManyCityInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput> | UserCreateWithoutCityInput[] | UserUncheckedCreateWithoutCityInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCityInput | UserCreateOrConnectWithoutCityInput[]
    createMany?: UserCreateManyCityInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type CompanyUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput> | CompanyCreateWithoutCityInput[] | CompanyUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutCityInput | CompanyCreateOrConnectWithoutCityInput[]
    createMany?: CompanyCreateManyCityInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type UserUpdateManyWithoutCityNestedInput = {
    create?: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput> | UserCreateWithoutCityInput[] | UserUncheckedCreateWithoutCityInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCityInput | UserCreateOrConnectWithoutCityInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCityInput | UserUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: UserCreateManyCityInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCityInput | UserUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCityInput | UserUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type CompanyUpdateManyWithoutCityNestedInput = {
    create?: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput> | CompanyCreateWithoutCityInput[] | CompanyUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutCityInput | CompanyCreateOrConnectWithoutCityInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutCityInput | CompanyUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CompanyCreateManyCityInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutCityInput | CompanyUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutCityInput | CompanyUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput> | UserCreateWithoutCityInput[] | UserUncheckedCreateWithoutCityInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCityInput | UserCreateOrConnectWithoutCityInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCityInput | UserUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: UserCreateManyCityInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCityInput | UserUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCityInput | UserUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type CompanyUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput> | CompanyCreateWithoutCityInput[] | CompanyUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutCityInput | CompanyCreateOrConnectWithoutCityInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutCityInput | CompanyUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CompanyCreateManyCityInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutCityInput | CompanyUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutCityInput | CompanyUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type UserCreateNestedManyWithoutPositionInput = {
    create?: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput> | UserCreateWithoutPositionInput[] | UserUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: UserCreateOrConnectWithoutPositionInput | UserCreateOrConnectWithoutPositionInput[]
    createMany?: UserCreateManyPositionInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type CompanyCreateNestedManyWithoutContactPositionInput = {
    create?: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput> | CompanyCreateWithoutContactPositionInput[] | CompanyUncheckedCreateWithoutContactPositionInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutContactPositionInput | CompanyCreateOrConnectWithoutContactPositionInput[]
    createMany?: CompanyCreateManyContactPositionInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type ElectedMemberCreateNestedManyWithoutPositionInput = {
    create?: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput> | ElectedMemberCreateWithoutPositionInput[] | ElectedMemberUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutPositionInput | ElectedMemberCreateOrConnectWithoutPositionInput[]
    createMany?: ElectedMemberCreateManyPositionInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutPositionInput = {
    create?: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput> | UserCreateWithoutPositionInput[] | UserUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: UserCreateOrConnectWithoutPositionInput | UserCreateOrConnectWithoutPositionInput[]
    createMany?: UserCreateManyPositionInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type CompanyUncheckedCreateNestedManyWithoutContactPositionInput = {
    create?: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput> | CompanyCreateWithoutContactPositionInput[] | CompanyUncheckedCreateWithoutContactPositionInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutContactPositionInput | CompanyCreateOrConnectWithoutContactPositionInput[]
    createMany?: CompanyCreateManyContactPositionInputEnvelope
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutPositionInput = {
    create?: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput> | ElectedMemberCreateWithoutPositionInput[] | ElectedMemberUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutPositionInput | ElectedMemberCreateOrConnectWithoutPositionInput[]
    createMany?: ElectedMemberCreateManyPositionInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserUpdateManyWithoutPositionNestedInput = {
    create?: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput> | UserCreateWithoutPositionInput[] | UserUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: UserCreateOrConnectWithoutPositionInput | UserCreateOrConnectWithoutPositionInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutPositionInput | UserUpsertWithWhereUniqueWithoutPositionInput[]
    createMany?: UserCreateManyPositionInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutPositionInput | UserUpdateWithWhereUniqueWithoutPositionInput[]
    updateMany?: UserUpdateManyWithWhereWithoutPositionInput | UserUpdateManyWithWhereWithoutPositionInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type CompanyUpdateManyWithoutContactPositionNestedInput = {
    create?: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput> | CompanyCreateWithoutContactPositionInput[] | CompanyUncheckedCreateWithoutContactPositionInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutContactPositionInput | CompanyCreateOrConnectWithoutContactPositionInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutContactPositionInput | CompanyUpsertWithWhereUniqueWithoutContactPositionInput[]
    createMany?: CompanyCreateManyContactPositionInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutContactPositionInput | CompanyUpdateWithWhereUniqueWithoutContactPositionInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutContactPositionInput | CompanyUpdateManyWithWhereWithoutContactPositionInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type ElectedMemberUpdateManyWithoutPositionNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput> | ElectedMemberCreateWithoutPositionInput[] | ElectedMemberUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutPositionInput | ElectedMemberCreateOrConnectWithoutPositionInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutPositionInput | ElectedMemberUpsertWithWhereUniqueWithoutPositionInput[]
    createMany?: ElectedMemberCreateManyPositionInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutPositionInput | ElectedMemberUpdateWithWhereUniqueWithoutPositionInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutPositionInput | ElectedMemberUpdateManyWithWhereWithoutPositionInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutPositionNestedInput = {
    create?: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput> | UserCreateWithoutPositionInput[] | UserUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: UserCreateOrConnectWithoutPositionInput | UserCreateOrConnectWithoutPositionInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutPositionInput | UserUpsertWithWhereUniqueWithoutPositionInput[]
    createMany?: UserCreateManyPositionInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutPositionInput | UserUpdateWithWhereUniqueWithoutPositionInput[]
    updateMany?: UserUpdateManyWithWhereWithoutPositionInput | UserUpdateManyWithWhereWithoutPositionInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type CompanyUncheckedUpdateManyWithoutContactPositionNestedInput = {
    create?: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput> | CompanyCreateWithoutContactPositionInput[] | CompanyUncheckedCreateWithoutContactPositionInput[]
    connectOrCreate?: CompanyCreateOrConnectWithoutContactPositionInput | CompanyCreateOrConnectWithoutContactPositionInput[]
    upsert?: CompanyUpsertWithWhereUniqueWithoutContactPositionInput | CompanyUpsertWithWhereUniqueWithoutContactPositionInput[]
    createMany?: CompanyCreateManyContactPositionInputEnvelope
    set?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    disconnect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    delete?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    connect?: CompanyWhereUniqueInput | CompanyWhereUniqueInput[]
    update?: CompanyUpdateWithWhereUniqueWithoutContactPositionInput | CompanyUpdateWithWhereUniqueWithoutContactPositionInput[]
    updateMany?: CompanyUpdateManyWithWhereWithoutContactPositionInput | CompanyUpdateManyWithWhereWithoutContactPositionInput[]
    deleteMany?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutPositionNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput> | ElectedMemberCreateWithoutPositionInput[] | ElectedMemberUncheckedCreateWithoutPositionInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutPositionInput | ElectedMemberCreateOrConnectWithoutPositionInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutPositionInput | ElectedMemberUpsertWithWhereUniqueWithoutPositionInput[]
    createMany?: ElectedMemberCreateManyPositionInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutPositionInput | ElectedMemberUpdateWithWhereUniqueWithoutPositionInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutPositionInput | ElectedMemberUpdateManyWithWhereWithoutPositionInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type ActivityCreateNestedManyWithoutActivityFamilyInput = {
    create?: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput> | ActivityCreateWithoutActivityFamilyInput[] | ActivityUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ActivityCreateOrConnectWithoutActivityFamilyInput | ActivityCreateOrConnectWithoutActivityFamilyInput[]
    createMany?: ActivityCreateManyActivityFamilyInputEnvelope
    connect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
  }

  export type ElectedMemberCreateNestedManyWithoutActivityFamilyInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput> | ElectedMemberCreateWithoutActivityFamilyInput[] | ElectedMemberUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityFamilyInput | ElectedMemberCreateOrConnectWithoutActivityFamilyInput[]
    createMany?: ElectedMemberCreateManyActivityFamilyInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type ActivityUncheckedCreateNestedManyWithoutActivityFamilyInput = {
    create?: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput> | ActivityCreateWithoutActivityFamilyInput[] | ActivityUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ActivityCreateOrConnectWithoutActivityFamilyInput | ActivityCreateOrConnectWithoutActivityFamilyInput[]
    createMany?: ActivityCreateManyActivityFamilyInputEnvelope
    connect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutActivityFamilyInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput> | ElectedMemberCreateWithoutActivityFamilyInput[] | ElectedMemberUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityFamilyInput | ElectedMemberCreateOrConnectWithoutActivityFamilyInput[]
    createMany?: ElectedMemberCreateManyActivityFamilyInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type ActivityUpdateManyWithoutActivityFamilyNestedInput = {
    create?: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput> | ActivityCreateWithoutActivityFamilyInput[] | ActivityUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ActivityCreateOrConnectWithoutActivityFamilyInput | ActivityCreateOrConnectWithoutActivityFamilyInput[]
    upsert?: ActivityUpsertWithWhereUniqueWithoutActivityFamilyInput | ActivityUpsertWithWhereUniqueWithoutActivityFamilyInput[]
    createMany?: ActivityCreateManyActivityFamilyInputEnvelope
    set?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    disconnect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    delete?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    connect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    update?: ActivityUpdateWithWhereUniqueWithoutActivityFamilyInput | ActivityUpdateWithWhereUniqueWithoutActivityFamilyInput[]
    updateMany?: ActivityUpdateManyWithWhereWithoutActivityFamilyInput | ActivityUpdateManyWithWhereWithoutActivityFamilyInput[]
    deleteMany?: ActivityScalarWhereInput | ActivityScalarWhereInput[]
  }

  export type ElectedMemberUpdateManyWithoutActivityFamilyNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput> | ElectedMemberCreateWithoutActivityFamilyInput[] | ElectedMemberUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityFamilyInput | ElectedMemberCreateOrConnectWithoutActivityFamilyInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutActivityFamilyInput | ElectedMemberUpsertWithWhereUniqueWithoutActivityFamilyInput[]
    createMany?: ElectedMemberCreateManyActivityFamilyInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutActivityFamilyInput | ElectedMemberUpdateWithWhereUniqueWithoutActivityFamilyInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutActivityFamilyInput | ElectedMemberUpdateManyWithWhereWithoutActivityFamilyInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type ActivityUncheckedUpdateManyWithoutActivityFamilyNestedInput = {
    create?: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput> | ActivityCreateWithoutActivityFamilyInput[] | ActivityUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ActivityCreateOrConnectWithoutActivityFamilyInput | ActivityCreateOrConnectWithoutActivityFamilyInput[]
    upsert?: ActivityUpsertWithWhereUniqueWithoutActivityFamilyInput | ActivityUpsertWithWhereUniqueWithoutActivityFamilyInput[]
    createMany?: ActivityCreateManyActivityFamilyInputEnvelope
    set?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    disconnect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    delete?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    connect?: ActivityWhereUniqueInput | ActivityWhereUniqueInput[]
    update?: ActivityUpdateWithWhereUniqueWithoutActivityFamilyInput | ActivityUpdateWithWhereUniqueWithoutActivityFamilyInput[]
    updateMany?: ActivityUpdateManyWithWhereWithoutActivityFamilyInput | ActivityUpdateManyWithWhereWithoutActivityFamilyInput[]
    deleteMany?: ActivityScalarWhereInput | ActivityScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutActivityFamilyNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput> | ElectedMemberCreateWithoutActivityFamilyInput[] | ElectedMemberUncheckedCreateWithoutActivityFamilyInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityFamilyInput | ElectedMemberCreateOrConnectWithoutActivityFamilyInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutActivityFamilyInput | ElectedMemberUpsertWithWhereUniqueWithoutActivityFamilyInput[]
    createMany?: ElectedMemberCreateManyActivityFamilyInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutActivityFamilyInput | ElectedMemberUpdateWithWhereUniqueWithoutActivityFamilyInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutActivityFamilyInput | ElectedMemberUpdateManyWithWhereWithoutActivityFamilyInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type ActivityFamilyCreateNestedOneWithoutActivitiesInput = {
    create?: XOR<ActivityFamilyCreateWithoutActivitiesInput, ActivityFamilyUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: ActivityFamilyCreateOrConnectWithoutActivitiesInput
    connect?: ActivityFamilyWhereUniqueInput
  }

  export type ElectedMemberCreateNestedManyWithoutActivityInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput> | ElectedMemberCreateWithoutActivityInput[] | ElectedMemberUncheckedCreateWithoutActivityInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityInput | ElectedMemberCreateOrConnectWithoutActivityInput[]
    createMany?: ElectedMemberCreateManyActivityInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutActivityInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput> | ElectedMemberCreateWithoutActivityInput[] | ElectedMemberUncheckedCreateWithoutActivityInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityInput | ElectedMemberCreateOrConnectWithoutActivityInput[]
    createMany?: ElectedMemberCreateManyActivityInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type ActivityFamilyUpdateOneRequiredWithoutActivitiesNestedInput = {
    create?: XOR<ActivityFamilyCreateWithoutActivitiesInput, ActivityFamilyUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: ActivityFamilyCreateOrConnectWithoutActivitiesInput
    upsert?: ActivityFamilyUpsertWithoutActivitiesInput
    connect?: ActivityFamilyWhereUniqueInput
    update?: XOR<XOR<ActivityFamilyUpdateToOneWithWhereWithoutActivitiesInput, ActivityFamilyUpdateWithoutActivitiesInput>, ActivityFamilyUncheckedUpdateWithoutActivitiesInput>
  }

  export type ElectedMemberUpdateManyWithoutActivityNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput> | ElectedMemberCreateWithoutActivityInput[] | ElectedMemberUncheckedCreateWithoutActivityInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityInput | ElectedMemberCreateOrConnectWithoutActivityInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutActivityInput | ElectedMemberUpsertWithWhereUniqueWithoutActivityInput[]
    createMany?: ElectedMemberCreateManyActivityInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutActivityInput | ElectedMemberUpdateWithWhereUniqueWithoutActivityInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutActivityInput | ElectedMemberUpdateManyWithWhereWithoutActivityInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutActivityNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput> | ElectedMemberCreateWithoutActivityInput[] | ElectedMemberUncheckedCreateWithoutActivityInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutActivityInput | ElectedMemberCreateOrConnectWithoutActivityInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutActivityInput | ElectedMemberUpsertWithWhereUniqueWithoutActivityInput[]
    createMany?: ElectedMemberCreateManyActivityInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutActivityInput | ElectedMemberUpdateWithWhereUniqueWithoutActivityInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutActivityInput | ElectedMemberUpdateManyWithWhereWithoutActivityInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type ElectedMemberCreateNestedManyWithoutProvinceInput = {
    create?: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput> | ElectedMemberCreateWithoutProvinceInput[] | ElectedMemberUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutProvinceInput | ElectedMemberCreateOrConnectWithoutProvinceInput[]
    createMany?: ElectedMemberCreateManyProvinceInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserCreateNestedManyWithoutProvinceInput = {
    create?: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput> | UserCreateWithoutProvinceInput[] | UserUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: UserCreateOrConnectWithoutProvinceInput | UserCreateOrConnectWithoutProvinceInput[]
    createMany?: UserCreateManyProvinceInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutProvinceInput = {
    create?: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput> | ElectedMemberCreateWithoutProvinceInput[] | ElectedMemberUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutProvinceInput | ElectedMemberCreateOrConnectWithoutProvinceInput[]
    createMany?: ElectedMemberCreateManyProvinceInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutProvinceInput = {
    create?: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput> | UserCreateWithoutProvinceInput[] | UserUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: UserCreateOrConnectWithoutProvinceInput | UserCreateOrConnectWithoutProvinceInput[]
    createMany?: UserCreateManyProvinceInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUpdateManyWithoutProvinceNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput> | ElectedMemberCreateWithoutProvinceInput[] | ElectedMemberUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutProvinceInput | ElectedMemberCreateOrConnectWithoutProvinceInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutProvinceInput | ElectedMemberUpsertWithWhereUniqueWithoutProvinceInput[]
    createMany?: ElectedMemberCreateManyProvinceInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutProvinceInput | ElectedMemberUpdateWithWhereUniqueWithoutProvinceInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutProvinceInput | ElectedMemberUpdateManyWithWhereWithoutProvinceInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUpdateManyWithoutProvinceNestedInput = {
    create?: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput> | UserCreateWithoutProvinceInput[] | UserUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: UserCreateOrConnectWithoutProvinceInput | UserCreateOrConnectWithoutProvinceInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutProvinceInput | UserUpsertWithWhereUniqueWithoutProvinceInput[]
    createMany?: UserCreateManyProvinceInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutProvinceInput | UserUpdateWithWhereUniqueWithoutProvinceInput[]
    updateMany?: UserUpdateManyWithWhereWithoutProvinceInput | UserUpdateManyWithWhereWithoutProvinceInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutProvinceNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput> | ElectedMemberCreateWithoutProvinceInput[] | ElectedMemberUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutProvinceInput | ElectedMemberCreateOrConnectWithoutProvinceInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutProvinceInput | ElectedMemberUpsertWithWhereUniqueWithoutProvinceInput[]
    createMany?: ElectedMemberCreateManyProvinceInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutProvinceInput | ElectedMemberUpdateWithWhereUniqueWithoutProvinceInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutProvinceInput | ElectedMemberUpdateManyWithWhereWithoutProvinceInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutProvinceNestedInput = {
    create?: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput> | UserCreateWithoutProvinceInput[] | UserUncheckedCreateWithoutProvinceInput[]
    connectOrCreate?: UserCreateOrConnectWithoutProvinceInput | UserCreateOrConnectWithoutProvinceInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutProvinceInput | UserUpsertWithWhereUniqueWithoutProvinceInput[]
    createMany?: UserCreateManyProvinceInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutProvinceInput | UserUpdateWithWhereUniqueWithoutProvinceInput[]
    updateMany?: UserUpdateManyWithWhereWithoutProvinceInput | UserUpdateManyWithWhereWithoutProvinceInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type EditionCreateNestedManyWithoutCategoryInput = {
    create?: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput> | EditionCreateWithoutCategoryInput[] | EditionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: EditionCreateOrConnectWithoutCategoryInput | EditionCreateOrConnectWithoutCategoryInput[]
    createMany?: EditionCreateManyCategoryInputEnvelope
    connect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
  }

  export type EditionUncheckedCreateNestedManyWithoutCategoryInput = {
    create?: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput> | EditionCreateWithoutCategoryInput[] | EditionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: EditionCreateOrConnectWithoutCategoryInput | EditionCreateOrConnectWithoutCategoryInput[]
    createMany?: EditionCreateManyCategoryInputEnvelope
    connect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
  }

  export type EditionUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput> | EditionCreateWithoutCategoryInput[] | EditionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: EditionCreateOrConnectWithoutCategoryInput | EditionCreateOrConnectWithoutCategoryInput[]
    upsert?: EditionUpsertWithWhereUniqueWithoutCategoryInput | EditionUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: EditionCreateManyCategoryInputEnvelope
    set?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    disconnect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    delete?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    connect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    update?: EditionUpdateWithWhereUniqueWithoutCategoryInput | EditionUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: EditionUpdateManyWithWhereWithoutCategoryInput | EditionUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: EditionScalarWhereInput | EditionScalarWhereInput[]
  }

  export type EditionUncheckedUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput> | EditionCreateWithoutCategoryInput[] | EditionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: EditionCreateOrConnectWithoutCategoryInput | EditionCreateOrConnectWithoutCategoryInput[]
    upsert?: EditionUpsertWithWhereUniqueWithoutCategoryInput | EditionUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: EditionCreateManyCategoryInputEnvelope
    set?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    disconnect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    delete?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    connect?: EditionWhereUniqueInput | EditionWhereUniqueInput[]
    update?: EditionUpdateWithWhereUniqueWithoutCategoryInput | EditionUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: EditionUpdateManyWithWhereWithoutCategoryInput | EditionUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: EditionScalarWhereInput | EditionScalarWhereInput[]
  }

  export type ElectedMemberCreateNestedManyWithoutMandateInput = {
    create?: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput> | ElectedMemberCreateWithoutMandateInput[] | ElectedMemberUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutMandateInput | ElectedMemberCreateOrConnectWithoutMandateInput[]
    createMany?: ElectedMemberCreateManyMandateInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserCreateNestedManyWithoutMandateInput = {
    create?: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput> | UserCreateWithoutMandateInput[] | UserUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: UserCreateOrConnectWithoutMandateInput | UserCreateOrConnectWithoutMandateInput[]
    createMany?: UserCreateManyMandateInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutMandateInput = {
    create?: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput> | ElectedMemberCreateWithoutMandateInput[] | ElectedMemberUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutMandateInput | ElectedMemberCreateOrConnectWithoutMandateInput[]
    createMany?: ElectedMemberCreateManyMandateInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutMandateInput = {
    create?: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput> | UserCreateWithoutMandateInput[] | UserUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: UserCreateOrConnectWithoutMandateInput | UserCreateOrConnectWithoutMandateInput[]
    createMany?: UserCreateManyMandateInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUpdateManyWithoutMandateNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput> | ElectedMemberCreateWithoutMandateInput[] | ElectedMemberUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutMandateInput | ElectedMemberCreateOrConnectWithoutMandateInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutMandateInput | ElectedMemberUpsertWithWhereUniqueWithoutMandateInput[]
    createMany?: ElectedMemberCreateManyMandateInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutMandateInput | ElectedMemberUpdateWithWhereUniqueWithoutMandateInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutMandateInput | ElectedMemberUpdateManyWithWhereWithoutMandateInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUpdateManyWithoutMandateNestedInput = {
    create?: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput> | UserCreateWithoutMandateInput[] | UserUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: UserCreateOrConnectWithoutMandateInput | UserCreateOrConnectWithoutMandateInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutMandateInput | UserUpsertWithWhereUniqueWithoutMandateInput[]
    createMany?: UserCreateManyMandateInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutMandateInput | UserUpdateWithWhereUniqueWithoutMandateInput[]
    updateMany?: UserUpdateManyWithWhereWithoutMandateInput | UserUpdateManyWithWhereWithoutMandateInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutMandateNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput> | ElectedMemberCreateWithoutMandateInput[] | ElectedMemberUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutMandateInput | ElectedMemberCreateOrConnectWithoutMandateInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutMandateInput | ElectedMemberUpsertWithWhereUniqueWithoutMandateInput[]
    createMany?: ElectedMemberCreateManyMandateInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutMandateInput | ElectedMemberUpdateWithWhereUniqueWithoutMandateInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutMandateInput | ElectedMemberUpdateManyWithWhereWithoutMandateInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutMandateNestedInput = {
    create?: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput> | UserCreateWithoutMandateInput[] | UserUncheckedCreateWithoutMandateInput[]
    connectOrCreate?: UserCreateOrConnectWithoutMandateInput | UserCreateOrConnectWithoutMandateInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutMandateInput | UserUpsertWithWhereUniqueWithoutMandateInput[]
    createMany?: UserCreateManyMandateInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutMandateInput | UserUpdateWithWhereUniqueWithoutMandateInput[]
    updateMany?: UserUpdateManyWithWhereWithoutMandateInput | UserUpdateManyWithWhereWithoutMandateInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type ElectedMemberCreateNestedManyWithoutCollegeInput = {
    create?: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput> | ElectedMemberCreateWithoutCollegeInput[] | ElectedMemberUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutCollegeInput | ElectedMemberCreateOrConnectWithoutCollegeInput[]
    createMany?: ElectedMemberCreateManyCollegeInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserCreateNestedManyWithoutCollegeInput = {
    create?: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput> | UserCreateWithoutCollegeInput[] | UserUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCollegeInput | UserCreateOrConnectWithoutCollegeInput[]
    createMany?: UserCreateManyCollegeInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUncheckedCreateNestedManyWithoutCollegeInput = {
    create?: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput> | ElectedMemberCreateWithoutCollegeInput[] | ElectedMemberUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutCollegeInput | ElectedMemberCreateOrConnectWithoutCollegeInput[]
    createMany?: ElectedMemberCreateManyCollegeInputEnvelope
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutCollegeInput = {
    create?: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput> | UserCreateWithoutCollegeInput[] | UserUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCollegeInput | UserCreateOrConnectWithoutCollegeInput[]
    createMany?: UserCreateManyCollegeInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type ElectedMemberUpdateManyWithoutCollegeNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput> | ElectedMemberCreateWithoutCollegeInput[] | ElectedMemberUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutCollegeInput | ElectedMemberCreateOrConnectWithoutCollegeInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutCollegeInput | ElectedMemberUpsertWithWhereUniqueWithoutCollegeInput[]
    createMany?: ElectedMemberCreateManyCollegeInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutCollegeInput | ElectedMemberUpdateWithWhereUniqueWithoutCollegeInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutCollegeInput | ElectedMemberUpdateManyWithWhereWithoutCollegeInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUpdateManyWithoutCollegeNestedInput = {
    create?: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput> | UserCreateWithoutCollegeInput[] | UserUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCollegeInput | UserCreateOrConnectWithoutCollegeInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCollegeInput | UserUpsertWithWhereUniqueWithoutCollegeInput[]
    createMany?: UserCreateManyCollegeInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCollegeInput | UserUpdateWithWhereUniqueWithoutCollegeInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCollegeInput | UserUpdateManyWithWhereWithoutCollegeInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type ElectedMemberUncheckedUpdateManyWithoutCollegeNestedInput = {
    create?: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput> | ElectedMemberCreateWithoutCollegeInput[] | ElectedMemberUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: ElectedMemberCreateOrConnectWithoutCollegeInput | ElectedMemberCreateOrConnectWithoutCollegeInput[]
    upsert?: ElectedMemberUpsertWithWhereUniqueWithoutCollegeInput | ElectedMemberUpsertWithWhereUniqueWithoutCollegeInput[]
    createMany?: ElectedMemberCreateManyCollegeInputEnvelope
    set?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    disconnect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    delete?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    connect?: ElectedMemberWhereUniqueInput | ElectedMemberWhereUniqueInput[]
    update?: ElectedMemberUpdateWithWhereUniqueWithoutCollegeInput | ElectedMemberUpdateWithWhereUniqueWithoutCollegeInput[]
    updateMany?: ElectedMemberUpdateManyWithWhereWithoutCollegeInput | ElectedMemberUpdateManyWithWhereWithoutCollegeInput[]
    deleteMany?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutCollegeNestedInput = {
    create?: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput> | UserCreateWithoutCollegeInput[] | UserUncheckedCreateWithoutCollegeInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCollegeInput | UserCreateOrConnectWithoutCollegeInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCollegeInput | UserUpsertWithWhereUniqueWithoutCollegeInput[]
    createMany?: UserCreateManyCollegeInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCollegeInput | UserUpdateWithWhereUniqueWithoutCollegeInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCollegeInput | UserUpdateManyWithWhereWithoutCollegeInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type ElectedMemberCreatecommissionsInput = {
    set: string[]
  }

  export type PositionCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<PositionCreateWithoutElectedMembersInput, PositionUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: PositionCreateOrConnectWithoutElectedMembersInput
    connect?: PositionWhereUniqueInput
  }

  export type ActivityFamilyCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<ActivityFamilyCreateWithoutElectedMembersInput, ActivityFamilyUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ActivityFamilyCreateOrConnectWithoutElectedMembersInput
    connect?: ActivityFamilyWhereUniqueInput
  }

  export type ActivityCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<ActivityCreateWithoutElectedMembersInput, ActivityUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ActivityCreateOrConnectWithoutElectedMembersInput
    connect?: ActivityWhereUniqueInput
  }

  export type CollegeCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<CollegeCreateWithoutElectedMembersInput, CollegeUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: CollegeCreateOrConnectWithoutElectedMembersInput
    connect?: CollegeWhereUniqueInput
  }

  export type ProvinceCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<ProvinceCreateWithoutElectedMembersInput, ProvinceUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ProvinceCreateOrConnectWithoutElectedMembersInput
    connect?: ProvinceWhereUniqueInput
  }

  export type MandateCreateNestedOneWithoutElectedMembersInput = {
    create?: XOR<MandateCreateWithoutElectedMembersInput, MandateUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: MandateCreateOrConnectWithoutElectedMembersInput
    connect?: MandateWhereUniqueInput
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type ElectedMemberUpdatecommissionsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type PositionUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<PositionCreateWithoutElectedMembersInput, PositionUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: PositionCreateOrConnectWithoutElectedMembersInput
    upsert?: PositionUpsertWithoutElectedMembersInput
    connect?: PositionWhereUniqueInput
    update?: XOR<XOR<PositionUpdateToOneWithWhereWithoutElectedMembersInput, PositionUpdateWithoutElectedMembersInput>, PositionUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<ActivityFamilyCreateWithoutElectedMembersInput, ActivityFamilyUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ActivityFamilyCreateOrConnectWithoutElectedMembersInput
    upsert?: ActivityFamilyUpsertWithoutElectedMembersInput
    connect?: ActivityFamilyWhereUniqueInput
    update?: XOR<XOR<ActivityFamilyUpdateToOneWithWhereWithoutElectedMembersInput, ActivityFamilyUpdateWithoutElectedMembersInput>, ActivityFamilyUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ActivityUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<ActivityCreateWithoutElectedMembersInput, ActivityUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ActivityCreateOrConnectWithoutElectedMembersInput
    upsert?: ActivityUpsertWithoutElectedMembersInput
    connect?: ActivityWhereUniqueInput
    update?: XOR<XOR<ActivityUpdateToOneWithWhereWithoutElectedMembersInput, ActivityUpdateWithoutElectedMembersInput>, ActivityUncheckedUpdateWithoutElectedMembersInput>
  }

  export type CollegeUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<CollegeCreateWithoutElectedMembersInput, CollegeUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: CollegeCreateOrConnectWithoutElectedMembersInput
    upsert?: CollegeUpsertWithoutElectedMembersInput
    connect?: CollegeWhereUniqueInput
    update?: XOR<XOR<CollegeUpdateToOneWithWhereWithoutElectedMembersInput, CollegeUpdateWithoutElectedMembersInput>, CollegeUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<ProvinceCreateWithoutElectedMembersInput, ProvinceUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: ProvinceCreateOrConnectWithoutElectedMembersInput
    upsert?: ProvinceUpsertWithoutElectedMembersInput
    connect?: ProvinceWhereUniqueInput
    update?: XOR<XOR<ProvinceUpdateToOneWithWhereWithoutElectedMembersInput, ProvinceUpdateWithoutElectedMembersInput>, ProvinceUncheckedUpdateWithoutElectedMembersInput>
  }

  export type MandateUpdateOneRequiredWithoutElectedMembersNestedInput = {
    create?: XOR<MandateCreateWithoutElectedMembersInput, MandateUncheckedCreateWithoutElectedMembersInput>
    connectOrCreate?: MandateCreateOrConnectWithoutElectedMembersInput
    upsert?: MandateUpsertWithoutElectedMembersInput
    connect?: MandateWhereUniqueInput
    update?: XOR<XOR<MandateUpdateToOneWithWhereWithoutElectedMembersInput, MandateUpdateWithoutElectedMembersInput>, MandateUncheckedUpdateWithoutElectedMembersInput>
  }

  export type UserCreateexpertiseAreasInput = {
    set: string[]
  }

  export type UserCreateinterestAreasInput = {
    set: string[]
  }

  export type UserCreatecommissionsInput = {
    set: string[]
  }

  export type UserCreatepermissionsInput = {
    set: $Enums.Permission[]
  }

  export type CityCreateNestedOneWithoutUsersInput = {
    create?: XOR<CityCreateWithoutUsersInput, CityUncheckedCreateWithoutUsersInput>
    connectOrCreate?: CityCreateOrConnectWithoutUsersInput
    connect?: CityWhereUniqueInput
  }

  export type PositionCreateNestedOneWithoutUsersInput = {
    create?: XOR<PositionCreateWithoutUsersInput, PositionUncheckedCreateWithoutUsersInput>
    connectOrCreate?: PositionCreateOrConnectWithoutUsersInput
    connect?: PositionWhereUniqueInput
  }

  export type CompanyCreateNestedOneWithoutUsersInput = {
    create?: XOR<CompanyCreateWithoutUsersInput, CompanyUncheckedCreateWithoutUsersInput>
    connectOrCreate?: CompanyCreateOrConnectWithoutUsersInput
    connect?: CompanyWhereUniqueInput
  }

  export type CollegeCreateNestedOneWithoutUserInput = {
    create?: XOR<CollegeCreateWithoutUserInput, CollegeUncheckedCreateWithoutUserInput>
    connectOrCreate?: CollegeCreateOrConnectWithoutUserInput
    connect?: CollegeWhereUniqueInput
  }

  export type ProvinceCreateNestedOneWithoutUserInput = {
    create?: XOR<ProvinceCreateWithoutUserInput, ProvinceUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProvinceCreateOrConnectWithoutUserInput
    connect?: ProvinceWhereUniqueInput
  }

  export type MandateCreateNestedOneWithoutUserInput = {
    create?: XOR<MandateCreateWithoutUserInput, MandateUncheckedCreateWithoutUserInput>
    connectOrCreate?: MandateCreateOrConnectWithoutUserInput
    connect?: MandateWhereUniqueInput
  }

  export type ConnectionCreateNestedManyWithoutSenderInput = {
    create?: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput> | ConnectionCreateWithoutSenderInput[] | ConnectionUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutSenderInput | ConnectionCreateOrConnectWithoutSenderInput[]
    createMany?: ConnectionCreateManySenderInputEnvelope
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
  }

  export type ConnectionCreateNestedManyWithoutReceiverInput = {
    create?: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput> | ConnectionCreateWithoutReceiverInput[] | ConnectionUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutReceiverInput | ConnectionCreateOrConnectWithoutReceiverInput[]
    createMany?: ConnectionCreateManyReceiverInputEnvelope
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
  }

  export type MessageCreateNestedManyWithoutSenderInput = {
    create?: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput> | MessageCreateWithoutSenderInput[] | MessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutSenderInput | MessageCreateOrConnectWithoutSenderInput[]
    createMany?: MessageCreateManySenderInputEnvelope
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
  }

  export type MessageCreateNestedManyWithoutReceiverInput = {
    create?: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput> | MessageCreateWithoutReceiverInput[] | MessageUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutReceiverInput | MessageCreateOrConnectWithoutReceiverInput[]
    createMany?: MessageCreateManyReceiverInputEnvelope
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
  }

  export type OpportunityCreateNestedManyWithoutCreatorInput = {
    create?: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput> | OpportunityCreateWithoutCreatorInput[] | OpportunityUncheckedCreateWithoutCreatorInput[]
    connectOrCreate?: OpportunityCreateOrConnectWithoutCreatorInput | OpportunityCreateOrConnectWithoutCreatorInput[]
    createMany?: OpportunityCreateManyCreatorInputEnvelope
    connect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
  }

  export type OpportunityLikeCreateNestedManyWithoutUserInput = {
    create?: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput> | OpportunityLikeCreateWithoutUserInput[] | OpportunityLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutUserInput | OpportunityLikeCreateOrConnectWithoutUserInput[]
    createMany?: OpportunityLikeCreateManyUserInputEnvelope
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
  }

  export type OpportunityCommentCreateNestedManyWithoutUserInput = {
    create?: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput> | OpportunityCommentCreateWithoutUserInput[] | OpportunityCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutUserInput | OpportunityCommentCreateOrConnectWithoutUserInput[]
    createMany?: OpportunityCommentCreateManyUserInputEnvelope
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
  }

  export type EventLikeCreateNestedManyWithoutUserInput = {
    create?: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput> | EventLikeCreateWithoutUserInput[] | EventLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutUserInput | EventLikeCreateOrConnectWithoutUserInput[]
    createMany?: EventLikeCreateManyUserInputEnvelope
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
  }

  export type EventCommentCreateNestedManyWithoutUserInput = {
    create?: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput> | EventCommentCreateWithoutUserInput[] | EventCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutUserInput | EventCommentCreateOrConnectWithoutUserInput[]
    createMany?: EventCommentCreateManyUserInputEnvelope
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
  }

  export type AppointmentLikeCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput> | AppointmentLikeCreateWithoutUserInput[] | AppointmentLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutUserInput | AppointmentLikeCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentLikeCreateManyUserInputEnvelope
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
  }

  export type AppointmentCommentCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput> | AppointmentCommentCreateWithoutUserInput[] | AppointmentCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutUserInput | AppointmentCommentCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentCommentCreateManyUserInputEnvelope
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
  }

  export type NotificationCreateNestedManyWithoutUserInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type AppointmentRegistrationCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput> | AppointmentRegistrationCreateWithoutUserInput[] | AppointmentRegistrationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutUserInput | AppointmentRegistrationCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentRegistrationCreateManyUserInputEnvelope
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
  }

  export type ConnectionUncheckedCreateNestedManyWithoutSenderInput = {
    create?: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput> | ConnectionCreateWithoutSenderInput[] | ConnectionUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutSenderInput | ConnectionCreateOrConnectWithoutSenderInput[]
    createMany?: ConnectionCreateManySenderInputEnvelope
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
  }

  export type ConnectionUncheckedCreateNestedManyWithoutReceiverInput = {
    create?: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput> | ConnectionCreateWithoutReceiverInput[] | ConnectionUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutReceiverInput | ConnectionCreateOrConnectWithoutReceiverInput[]
    createMany?: ConnectionCreateManyReceiverInputEnvelope
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
  }

  export type MessageUncheckedCreateNestedManyWithoutSenderInput = {
    create?: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput> | MessageCreateWithoutSenderInput[] | MessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutSenderInput | MessageCreateOrConnectWithoutSenderInput[]
    createMany?: MessageCreateManySenderInputEnvelope
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
  }

  export type MessageUncheckedCreateNestedManyWithoutReceiverInput = {
    create?: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput> | MessageCreateWithoutReceiverInput[] | MessageUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutReceiverInput | MessageCreateOrConnectWithoutReceiverInput[]
    createMany?: MessageCreateManyReceiverInputEnvelope
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
  }

  export type OpportunityUncheckedCreateNestedManyWithoutCreatorInput = {
    create?: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput> | OpportunityCreateWithoutCreatorInput[] | OpportunityUncheckedCreateWithoutCreatorInput[]
    connectOrCreate?: OpportunityCreateOrConnectWithoutCreatorInput | OpportunityCreateOrConnectWithoutCreatorInput[]
    createMany?: OpportunityCreateManyCreatorInputEnvelope
    connect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
  }

  export type OpportunityLikeUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput> | OpportunityLikeCreateWithoutUserInput[] | OpportunityLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutUserInput | OpportunityLikeCreateOrConnectWithoutUserInput[]
    createMany?: OpportunityLikeCreateManyUserInputEnvelope
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
  }

  export type OpportunityCommentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput> | OpportunityCommentCreateWithoutUserInput[] | OpportunityCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutUserInput | OpportunityCommentCreateOrConnectWithoutUserInput[]
    createMany?: OpportunityCommentCreateManyUserInputEnvelope
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
  }

  export type EventLikeUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput> | EventLikeCreateWithoutUserInput[] | EventLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutUserInput | EventLikeCreateOrConnectWithoutUserInput[]
    createMany?: EventLikeCreateManyUserInputEnvelope
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
  }

  export type EventCommentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput> | EventCommentCreateWithoutUserInput[] | EventCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutUserInput | EventCommentCreateOrConnectWithoutUserInput[]
    createMany?: EventCommentCreateManyUserInputEnvelope
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
  }

  export type AppointmentLikeUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput> | AppointmentLikeCreateWithoutUserInput[] | AppointmentLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutUserInput | AppointmentLikeCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentLikeCreateManyUserInputEnvelope
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
  }

  export type AppointmentCommentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput> | AppointmentCommentCreateWithoutUserInput[] | AppointmentCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutUserInput | AppointmentCommentCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentCommentCreateManyUserInputEnvelope
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput> | AppointmentRegistrationCreateWithoutUserInput[] | AppointmentRegistrationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutUserInput | AppointmentRegistrationCreateOrConnectWithoutUserInput[]
    createMany?: AppointmentRegistrationCreateManyUserInputEnvelope
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
  }

  export type EnumCivilityFieldUpdateOperationsInput = {
    set?: $Enums.Civility
  }

  export type UserUpdateexpertiseAreasInput = {
    set?: string[]
    push?: string | string[]
  }

  export type UserUpdateinterestAreasInput = {
    set?: string[]
    push?: string | string[]
  }

  export type UserUpdatecommissionsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type EnumRoleFieldUpdateOperationsInput = {
    set?: $Enums.Role
  }

  export type UserUpdatepermissionsInput = {
    set?: $Enums.Permission[]
    push?: $Enums.Permission | $Enums.Permission[]
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type CityUpdateOneWithoutUsersNestedInput = {
    create?: XOR<CityCreateWithoutUsersInput, CityUncheckedCreateWithoutUsersInput>
    connectOrCreate?: CityCreateOrConnectWithoutUsersInput
    upsert?: CityUpsertWithoutUsersInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutUsersInput, CityUpdateWithoutUsersInput>, CityUncheckedUpdateWithoutUsersInput>
  }

  export type PositionUpdateOneWithoutUsersNestedInput = {
    create?: XOR<PositionCreateWithoutUsersInput, PositionUncheckedCreateWithoutUsersInput>
    connectOrCreate?: PositionCreateOrConnectWithoutUsersInput
    upsert?: PositionUpsertWithoutUsersInput
    disconnect?: PositionWhereInput | boolean
    delete?: PositionWhereInput | boolean
    connect?: PositionWhereUniqueInput
    update?: XOR<XOR<PositionUpdateToOneWithWhereWithoutUsersInput, PositionUpdateWithoutUsersInput>, PositionUncheckedUpdateWithoutUsersInput>
  }

  export type CompanyUpdateOneWithoutUsersNestedInput = {
    create?: XOR<CompanyCreateWithoutUsersInput, CompanyUncheckedCreateWithoutUsersInput>
    connectOrCreate?: CompanyCreateOrConnectWithoutUsersInput
    upsert?: CompanyUpsertWithoutUsersInput
    disconnect?: CompanyWhereInput | boolean
    delete?: CompanyWhereInput | boolean
    connect?: CompanyWhereUniqueInput
    update?: XOR<XOR<CompanyUpdateToOneWithWhereWithoutUsersInput, CompanyUpdateWithoutUsersInput>, CompanyUncheckedUpdateWithoutUsersInput>
  }

  export type CollegeUpdateOneWithoutUserNestedInput = {
    create?: XOR<CollegeCreateWithoutUserInput, CollegeUncheckedCreateWithoutUserInput>
    connectOrCreate?: CollegeCreateOrConnectWithoutUserInput
    upsert?: CollegeUpsertWithoutUserInput
    disconnect?: CollegeWhereInput | boolean
    delete?: CollegeWhereInput | boolean
    connect?: CollegeWhereUniqueInput
    update?: XOR<XOR<CollegeUpdateToOneWithWhereWithoutUserInput, CollegeUpdateWithoutUserInput>, CollegeUncheckedUpdateWithoutUserInput>
  }

  export type ProvinceUpdateOneWithoutUserNestedInput = {
    create?: XOR<ProvinceCreateWithoutUserInput, ProvinceUncheckedCreateWithoutUserInput>
    connectOrCreate?: ProvinceCreateOrConnectWithoutUserInput
    upsert?: ProvinceUpsertWithoutUserInput
    disconnect?: ProvinceWhereInput | boolean
    delete?: ProvinceWhereInput | boolean
    connect?: ProvinceWhereUniqueInput
    update?: XOR<XOR<ProvinceUpdateToOneWithWhereWithoutUserInput, ProvinceUpdateWithoutUserInput>, ProvinceUncheckedUpdateWithoutUserInput>
  }

  export type MandateUpdateOneWithoutUserNestedInput = {
    create?: XOR<MandateCreateWithoutUserInput, MandateUncheckedCreateWithoutUserInput>
    connectOrCreate?: MandateCreateOrConnectWithoutUserInput
    upsert?: MandateUpsertWithoutUserInput
    disconnect?: MandateWhereInput | boolean
    delete?: MandateWhereInput | boolean
    connect?: MandateWhereUniqueInput
    update?: XOR<XOR<MandateUpdateToOneWithWhereWithoutUserInput, MandateUpdateWithoutUserInput>, MandateUncheckedUpdateWithoutUserInput>
  }

  export type ConnectionUpdateManyWithoutSenderNestedInput = {
    create?: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput> | ConnectionCreateWithoutSenderInput[] | ConnectionUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutSenderInput | ConnectionCreateOrConnectWithoutSenderInput[]
    upsert?: ConnectionUpsertWithWhereUniqueWithoutSenderInput | ConnectionUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: ConnectionCreateManySenderInputEnvelope
    set?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    disconnect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    delete?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    update?: ConnectionUpdateWithWhereUniqueWithoutSenderInput | ConnectionUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: ConnectionUpdateManyWithWhereWithoutSenderInput | ConnectionUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
  }

  export type ConnectionUpdateManyWithoutReceiverNestedInput = {
    create?: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput> | ConnectionCreateWithoutReceiverInput[] | ConnectionUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutReceiverInput | ConnectionCreateOrConnectWithoutReceiverInput[]
    upsert?: ConnectionUpsertWithWhereUniqueWithoutReceiverInput | ConnectionUpsertWithWhereUniqueWithoutReceiverInput[]
    createMany?: ConnectionCreateManyReceiverInputEnvelope
    set?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    disconnect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    delete?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    update?: ConnectionUpdateWithWhereUniqueWithoutReceiverInput | ConnectionUpdateWithWhereUniqueWithoutReceiverInput[]
    updateMany?: ConnectionUpdateManyWithWhereWithoutReceiverInput | ConnectionUpdateManyWithWhereWithoutReceiverInput[]
    deleteMany?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
  }

  export type MessageUpdateManyWithoutSenderNestedInput = {
    create?: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput> | MessageCreateWithoutSenderInput[] | MessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutSenderInput | MessageCreateOrConnectWithoutSenderInput[]
    upsert?: MessageUpsertWithWhereUniqueWithoutSenderInput | MessageUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: MessageCreateManySenderInputEnvelope
    set?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    disconnect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    delete?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    update?: MessageUpdateWithWhereUniqueWithoutSenderInput | MessageUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: MessageUpdateManyWithWhereWithoutSenderInput | MessageUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: MessageScalarWhereInput | MessageScalarWhereInput[]
  }

  export type MessageUpdateManyWithoutReceiverNestedInput = {
    create?: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput> | MessageCreateWithoutReceiverInput[] | MessageUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutReceiverInput | MessageCreateOrConnectWithoutReceiverInput[]
    upsert?: MessageUpsertWithWhereUniqueWithoutReceiverInput | MessageUpsertWithWhereUniqueWithoutReceiverInput[]
    createMany?: MessageCreateManyReceiverInputEnvelope
    set?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    disconnect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    delete?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    update?: MessageUpdateWithWhereUniqueWithoutReceiverInput | MessageUpdateWithWhereUniqueWithoutReceiverInput[]
    updateMany?: MessageUpdateManyWithWhereWithoutReceiverInput | MessageUpdateManyWithWhereWithoutReceiverInput[]
    deleteMany?: MessageScalarWhereInput | MessageScalarWhereInput[]
  }

  export type OpportunityUpdateManyWithoutCreatorNestedInput = {
    create?: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput> | OpportunityCreateWithoutCreatorInput[] | OpportunityUncheckedCreateWithoutCreatorInput[]
    connectOrCreate?: OpportunityCreateOrConnectWithoutCreatorInput | OpportunityCreateOrConnectWithoutCreatorInput[]
    upsert?: OpportunityUpsertWithWhereUniqueWithoutCreatorInput | OpportunityUpsertWithWhereUniqueWithoutCreatorInput[]
    createMany?: OpportunityCreateManyCreatorInputEnvelope
    set?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    disconnect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    delete?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    connect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    update?: OpportunityUpdateWithWhereUniqueWithoutCreatorInput | OpportunityUpdateWithWhereUniqueWithoutCreatorInput[]
    updateMany?: OpportunityUpdateManyWithWhereWithoutCreatorInput | OpportunityUpdateManyWithWhereWithoutCreatorInput[]
    deleteMany?: OpportunityScalarWhereInput | OpportunityScalarWhereInput[]
  }

  export type OpportunityLikeUpdateManyWithoutUserNestedInput = {
    create?: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput> | OpportunityLikeCreateWithoutUserInput[] | OpportunityLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutUserInput | OpportunityLikeCreateOrConnectWithoutUserInput[]
    upsert?: OpportunityLikeUpsertWithWhereUniqueWithoutUserInput | OpportunityLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OpportunityLikeCreateManyUserInputEnvelope
    set?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    disconnect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    delete?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    update?: OpportunityLikeUpdateWithWhereUniqueWithoutUserInput | OpportunityLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OpportunityLikeUpdateManyWithWhereWithoutUserInput | OpportunityLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
  }

  export type OpportunityCommentUpdateManyWithoutUserNestedInput = {
    create?: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput> | OpportunityCommentCreateWithoutUserInput[] | OpportunityCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutUserInput | OpportunityCommentCreateOrConnectWithoutUserInput[]
    upsert?: OpportunityCommentUpsertWithWhereUniqueWithoutUserInput | OpportunityCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OpportunityCommentCreateManyUserInputEnvelope
    set?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    disconnect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    delete?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    update?: OpportunityCommentUpdateWithWhereUniqueWithoutUserInput | OpportunityCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OpportunityCommentUpdateManyWithWhereWithoutUserInput | OpportunityCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
  }

  export type EventLikeUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput> | EventLikeCreateWithoutUserInput[] | EventLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutUserInput | EventLikeCreateOrConnectWithoutUserInput[]
    upsert?: EventLikeUpsertWithWhereUniqueWithoutUserInput | EventLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventLikeCreateManyUserInputEnvelope
    set?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    disconnect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    delete?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    update?: EventLikeUpdateWithWhereUniqueWithoutUserInput | EventLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventLikeUpdateManyWithWhereWithoutUserInput | EventLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
  }

  export type EventCommentUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput> | EventCommentCreateWithoutUserInput[] | EventCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutUserInput | EventCommentCreateOrConnectWithoutUserInput[]
    upsert?: EventCommentUpsertWithWhereUniqueWithoutUserInput | EventCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventCommentCreateManyUserInputEnvelope
    set?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    disconnect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    delete?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    update?: EventCommentUpdateWithWhereUniqueWithoutUserInput | EventCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventCommentUpdateManyWithWhereWithoutUserInput | EventCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
  }

  export type AppointmentLikeUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput> | AppointmentLikeCreateWithoutUserInput[] | AppointmentLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutUserInput | AppointmentLikeCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentLikeUpsertWithWhereUniqueWithoutUserInput | AppointmentLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentLikeCreateManyUserInputEnvelope
    set?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    disconnect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    delete?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    update?: AppointmentLikeUpdateWithWhereUniqueWithoutUserInput | AppointmentLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentLikeUpdateManyWithWhereWithoutUserInput | AppointmentLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
  }

  export type AppointmentCommentUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput> | AppointmentCommentCreateWithoutUserInput[] | AppointmentCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutUserInput | AppointmentCommentCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentCommentUpsertWithWhereUniqueWithoutUserInput | AppointmentCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentCommentCreateManyUserInputEnvelope
    set?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    disconnect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    delete?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    update?: AppointmentCommentUpdateWithWhereUniqueWithoutUserInput | AppointmentCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentCommentUpdateManyWithWhereWithoutUserInput | AppointmentCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
  }

  export type NotificationUpdateManyWithoutUserNestedInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutUserInput | NotificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutUserInput | NotificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutUserInput | NotificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type AppointmentRegistrationUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput> | AppointmentRegistrationCreateWithoutUserInput[] | AppointmentRegistrationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutUserInput | AppointmentRegistrationCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentRegistrationUpsertWithWhereUniqueWithoutUserInput | AppointmentRegistrationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentRegistrationCreateManyUserInputEnvelope
    set?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    disconnect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    delete?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    update?: AppointmentRegistrationUpdateWithWhereUniqueWithoutUserInput | AppointmentRegistrationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentRegistrationUpdateManyWithWhereWithoutUserInput | AppointmentRegistrationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
  }

  export type ConnectionUncheckedUpdateManyWithoutSenderNestedInput = {
    create?: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput> | ConnectionCreateWithoutSenderInput[] | ConnectionUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutSenderInput | ConnectionCreateOrConnectWithoutSenderInput[]
    upsert?: ConnectionUpsertWithWhereUniqueWithoutSenderInput | ConnectionUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: ConnectionCreateManySenderInputEnvelope
    set?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    disconnect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    delete?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    update?: ConnectionUpdateWithWhereUniqueWithoutSenderInput | ConnectionUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: ConnectionUpdateManyWithWhereWithoutSenderInput | ConnectionUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
  }

  export type ConnectionUncheckedUpdateManyWithoutReceiverNestedInput = {
    create?: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput> | ConnectionCreateWithoutReceiverInput[] | ConnectionUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: ConnectionCreateOrConnectWithoutReceiverInput | ConnectionCreateOrConnectWithoutReceiverInput[]
    upsert?: ConnectionUpsertWithWhereUniqueWithoutReceiverInput | ConnectionUpsertWithWhereUniqueWithoutReceiverInput[]
    createMany?: ConnectionCreateManyReceiverInputEnvelope
    set?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    disconnect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    delete?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    connect?: ConnectionWhereUniqueInput | ConnectionWhereUniqueInput[]
    update?: ConnectionUpdateWithWhereUniqueWithoutReceiverInput | ConnectionUpdateWithWhereUniqueWithoutReceiverInput[]
    updateMany?: ConnectionUpdateManyWithWhereWithoutReceiverInput | ConnectionUpdateManyWithWhereWithoutReceiverInput[]
    deleteMany?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
  }

  export type MessageUncheckedUpdateManyWithoutSenderNestedInput = {
    create?: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput> | MessageCreateWithoutSenderInput[] | MessageUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutSenderInput | MessageCreateOrConnectWithoutSenderInput[]
    upsert?: MessageUpsertWithWhereUniqueWithoutSenderInput | MessageUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: MessageCreateManySenderInputEnvelope
    set?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    disconnect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    delete?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    update?: MessageUpdateWithWhereUniqueWithoutSenderInput | MessageUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: MessageUpdateManyWithWhereWithoutSenderInput | MessageUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: MessageScalarWhereInput | MessageScalarWhereInput[]
  }

  export type MessageUncheckedUpdateManyWithoutReceiverNestedInput = {
    create?: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput> | MessageCreateWithoutReceiverInput[] | MessageUncheckedCreateWithoutReceiverInput[]
    connectOrCreate?: MessageCreateOrConnectWithoutReceiverInput | MessageCreateOrConnectWithoutReceiverInput[]
    upsert?: MessageUpsertWithWhereUniqueWithoutReceiverInput | MessageUpsertWithWhereUniqueWithoutReceiverInput[]
    createMany?: MessageCreateManyReceiverInputEnvelope
    set?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    disconnect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    delete?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    connect?: MessageWhereUniqueInput | MessageWhereUniqueInput[]
    update?: MessageUpdateWithWhereUniqueWithoutReceiverInput | MessageUpdateWithWhereUniqueWithoutReceiverInput[]
    updateMany?: MessageUpdateManyWithWhereWithoutReceiverInput | MessageUpdateManyWithWhereWithoutReceiverInput[]
    deleteMany?: MessageScalarWhereInput | MessageScalarWhereInput[]
  }

  export type OpportunityUncheckedUpdateManyWithoutCreatorNestedInput = {
    create?: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput> | OpportunityCreateWithoutCreatorInput[] | OpportunityUncheckedCreateWithoutCreatorInput[]
    connectOrCreate?: OpportunityCreateOrConnectWithoutCreatorInput | OpportunityCreateOrConnectWithoutCreatorInput[]
    upsert?: OpportunityUpsertWithWhereUniqueWithoutCreatorInput | OpportunityUpsertWithWhereUniqueWithoutCreatorInput[]
    createMany?: OpportunityCreateManyCreatorInputEnvelope
    set?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    disconnect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    delete?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    connect?: OpportunityWhereUniqueInput | OpportunityWhereUniqueInput[]
    update?: OpportunityUpdateWithWhereUniqueWithoutCreatorInput | OpportunityUpdateWithWhereUniqueWithoutCreatorInput[]
    updateMany?: OpportunityUpdateManyWithWhereWithoutCreatorInput | OpportunityUpdateManyWithWhereWithoutCreatorInput[]
    deleteMany?: OpportunityScalarWhereInput | OpportunityScalarWhereInput[]
  }

  export type OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput> | OpportunityLikeCreateWithoutUserInput[] | OpportunityLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutUserInput | OpportunityLikeCreateOrConnectWithoutUserInput[]
    upsert?: OpportunityLikeUpsertWithWhereUniqueWithoutUserInput | OpportunityLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OpportunityLikeCreateManyUserInputEnvelope
    set?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    disconnect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    delete?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    update?: OpportunityLikeUpdateWithWhereUniqueWithoutUserInput | OpportunityLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OpportunityLikeUpdateManyWithWhereWithoutUserInput | OpportunityLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
  }

  export type OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput> | OpportunityCommentCreateWithoutUserInput[] | OpportunityCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutUserInput | OpportunityCommentCreateOrConnectWithoutUserInput[]
    upsert?: OpportunityCommentUpsertWithWhereUniqueWithoutUserInput | OpportunityCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OpportunityCommentCreateManyUserInputEnvelope
    set?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    disconnect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    delete?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    update?: OpportunityCommentUpdateWithWhereUniqueWithoutUserInput | OpportunityCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OpportunityCommentUpdateManyWithWhereWithoutUserInput | OpportunityCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
  }

  export type EventLikeUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput> | EventLikeCreateWithoutUserInput[] | EventLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutUserInput | EventLikeCreateOrConnectWithoutUserInput[]
    upsert?: EventLikeUpsertWithWhereUniqueWithoutUserInput | EventLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventLikeCreateManyUserInputEnvelope
    set?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    disconnect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    delete?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    update?: EventLikeUpdateWithWhereUniqueWithoutUserInput | EventLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventLikeUpdateManyWithWhereWithoutUserInput | EventLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
  }

  export type EventCommentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput> | EventCommentCreateWithoutUserInput[] | EventCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutUserInput | EventCommentCreateOrConnectWithoutUserInput[]
    upsert?: EventCommentUpsertWithWhereUniqueWithoutUserInput | EventCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: EventCommentCreateManyUserInputEnvelope
    set?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    disconnect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    delete?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    update?: EventCommentUpdateWithWhereUniqueWithoutUserInput | EventCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: EventCommentUpdateManyWithWhereWithoutUserInput | EventCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
  }

  export type AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput> | AppointmentLikeCreateWithoutUserInput[] | AppointmentLikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutUserInput | AppointmentLikeCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentLikeUpsertWithWhereUniqueWithoutUserInput | AppointmentLikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentLikeCreateManyUserInputEnvelope
    set?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    disconnect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    delete?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    update?: AppointmentLikeUpdateWithWhereUniqueWithoutUserInput | AppointmentLikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentLikeUpdateManyWithWhereWithoutUserInput | AppointmentLikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
  }

  export type AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput> | AppointmentCommentCreateWithoutUserInput[] | AppointmentCommentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutUserInput | AppointmentCommentCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentCommentUpsertWithWhereUniqueWithoutUserInput | AppointmentCommentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentCommentCreateManyUserInputEnvelope
    set?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    disconnect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    delete?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    update?: AppointmentCommentUpdateWithWhereUniqueWithoutUserInput | AppointmentCommentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentCommentUpdateManyWithWhereWithoutUserInput | AppointmentCommentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput> | NotificationCreateWithoutUserInput[] | NotificationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutUserInput | NotificationCreateOrConnectWithoutUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutUserInput | NotificationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: NotificationCreateManyUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutUserInput | NotificationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutUserInput | NotificationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput> | AppointmentRegistrationCreateWithoutUserInput[] | AppointmentRegistrationUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutUserInput | AppointmentRegistrationCreateOrConnectWithoutUserInput[]
    upsert?: AppointmentRegistrationUpsertWithWhereUniqueWithoutUserInput | AppointmentRegistrationUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AppointmentRegistrationCreateManyUserInputEnvelope
    set?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    disconnect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    delete?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    update?: AppointmentRegistrationUpdateWithWhereUniqueWithoutUserInput | AppointmentRegistrationUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AppointmentRegistrationUpdateManyWithWhereWithoutUserInput | AppointmentRegistrationUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutNotificationsInput = {
    create?: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutNotificationsInput
    connect?: UserWhereUniqueInput
  }

  export type EnumSourceFieldUpdateOperationsInput = {
    set?: $Enums.Source
  }

  export type UserUpdateOneRequiredWithoutNotificationsNestedInput = {
    create?: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutNotificationsInput
    upsert?: UserUpsertWithoutNotificationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutNotificationsInput, UserUpdateWithoutNotificationsInput>, UserUncheckedUpdateWithoutNotificationsInput>
  }

  export type CompanyCreateactivitiesFamiliesInput = {
    set: string[]
  }

  export type CompanyCreateactivitiesInput = {
    set: string[]
  }

  export type CompanyCreateimportCountriesInput = {
    set: string[]
  }

  export type CompanyCreateexportCountriesInput = {
    set: string[]
  }

  export type CityCreateNestedOneWithoutCompaniesInput = {
    create?: XOR<CityCreateWithoutCompaniesInput, CityUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: CityCreateOrConnectWithoutCompaniesInput
    connect?: CityWhereUniqueInput
  }

  export type PositionCreateNestedOneWithoutCompaniesInput = {
    create?: XOR<PositionCreateWithoutCompaniesInput, PositionUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: PositionCreateOrConnectWithoutCompaniesInput
    connect?: PositionWhereUniqueInput
  }

  export type TurnoverCreateNestedOneWithoutCompaniesInput = {
    create?: XOR<TurnoverCreateWithoutCompaniesInput, TurnoverUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: TurnoverCreateOrConnectWithoutCompaniesInput
    connect?: TurnoverWhereUniqueInput
  }

  export type NEmployeesCreateNestedOneWithoutCompaniesInput = {
    create?: XOR<NEmployeesCreateWithoutCompaniesInput, NEmployeesUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: NEmployeesCreateOrConnectWithoutCompaniesInput
    connect?: NEmployeesWhereUniqueInput
  }

  export type UserCreateNestedManyWithoutCompanyInput = {
    create?: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput> | UserCreateWithoutCompanyInput[] | UserUncheckedCreateWithoutCompanyInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCompanyInput | UserCreateOrConnectWithoutCompanyInput[]
    createMany?: UserCreateManyCompanyInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutCompanyInput = {
    create?: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput> | UserCreateWithoutCompanyInput[] | UserUncheckedCreateWithoutCompanyInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCompanyInput | UserCreateOrConnectWithoutCompanyInput[]
    createMany?: UserCreateManyCompanyInputEnvelope
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type EnumLegalFormFieldUpdateOperationsInput = {
    set?: $Enums.LegalForm
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type CompanyUpdateactivitiesFamiliesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type CompanyUpdateactivitiesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type CompanyUpdateimportCountriesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type CompanyUpdateexportCountriesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type CityUpdateOneWithoutCompaniesNestedInput = {
    create?: XOR<CityCreateWithoutCompaniesInput, CityUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: CityCreateOrConnectWithoutCompaniesInput
    upsert?: CityUpsertWithoutCompaniesInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutCompaniesInput, CityUpdateWithoutCompaniesInput>, CityUncheckedUpdateWithoutCompaniesInput>
  }

  export type PositionUpdateOneWithoutCompaniesNestedInput = {
    create?: XOR<PositionCreateWithoutCompaniesInput, PositionUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: PositionCreateOrConnectWithoutCompaniesInput
    upsert?: PositionUpsertWithoutCompaniesInput
    disconnect?: PositionWhereInput | boolean
    delete?: PositionWhereInput | boolean
    connect?: PositionWhereUniqueInput
    update?: XOR<XOR<PositionUpdateToOneWithWhereWithoutCompaniesInput, PositionUpdateWithoutCompaniesInput>, PositionUncheckedUpdateWithoutCompaniesInput>
  }

  export type TurnoverUpdateOneWithoutCompaniesNestedInput = {
    create?: XOR<TurnoverCreateWithoutCompaniesInput, TurnoverUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: TurnoverCreateOrConnectWithoutCompaniesInput
    upsert?: TurnoverUpsertWithoutCompaniesInput
    disconnect?: TurnoverWhereInput | boolean
    delete?: TurnoverWhereInput | boolean
    connect?: TurnoverWhereUniqueInput
    update?: XOR<XOR<TurnoverUpdateToOneWithWhereWithoutCompaniesInput, TurnoverUpdateWithoutCompaniesInput>, TurnoverUncheckedUpdateWithoutCompaniesInput>
  }

  export type NEmployeesUpdateOneWithoutCompaniesNestedInput = {
    create?: XOR<NEmployeesCreateWithoutCompaniesInput, NEmployeesUncheckedCreateWithoutCompaniesInput>
    connectOrCreate?: NEmployeesCreateOrConnectWithoutCompaniesInput
    upsert?: NEmployeesUpsertWithoutCompaniesInput
    disconnect?: NEmployeesWhereInput | boolean
    delete?: NEmployeesWhereInput | boolean
    connect?: NEmployeesWhereUniqueInput
    update?: XOR<XOR<NEmployeesUpdateToOneWithWhereWithoutCompaniesInput, NEmployeesUpdateWithoutCompaniesInput>, NEmployeesUncheckedUpdateWithoutCompaniesInput>
  }

  export type UserUpdateManyWithoutCompanyNestedInput = {
    create?: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput> | UserCreateWithoutCompanyInput[] | UserUncheckedCreateWithoutCompanyInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCompanyInput | UserCreateOrConnectWithoutCompanyInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCompanyInput | UserUpsertWithWhereUniqueWithoutCompanyInput[]
    createMany?: UserCreateManyCompanyInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCompanyInput | UserUpdateWithWhereUniqueWithoutCompanyInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCompanyInput | UserUpdateManyWithWhereWithoutCompanyInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutCompanyNestedInput = {
    create?: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput> | UserCreateWithoutCompanyInput[] | UserUncheckedCreateWithoutCompanyInput[]
    connectOrCreate?: UserCreateOrConnectWithoutCompanyInput | UserCreateOrConnectWithoutCompanyInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutCompanyInput | UserUpsertWithWhereUniqueWithoutCompanyInput[]
    createMany?: UserCreateManyCompanyInputEnvelope
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutCompanyInput | UserUpdateWithWhereUniqueWithoutCompanyInput[]
    updateMany?: UserUpdateManyWithWhereWithoutCompanyInput | UserUpdateManyWithWhereWithoutCompanyInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutConnectionsSentInput = {
    create?: XOR<UserCreateWithoutConnectionsSentInput, UserUncheckedCreateWithoutConnectionsSentInput>
    connectOrCreate?: UserCreateOrConnectWithoutConnectionsSentInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutConnectionsReceivedInput = {
    create?: XOR<UserCreateWithoutConnectionsReceivedInput, UserUncheckedCreateWithoutConnectionsReceivedInput>
    connectOrCreate?: UserCreateOrConnectWithoutConnectionsReceivedInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutConnectionsSentNestedInput = {
    create?: XOR<UserCreateWithoutConnectionsSentInput, UserUncheckedCreateWithoutConnectionsSentInput>
    connectOrCreate?: UserCreateOrConnectWithoutConnectionsSentInput
    upsert?: UserUpsertWithoutConnectionsSentInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutConnectionsSentInput, UserUpdateWithoutConnectionsSentInput>, UserUncheckedUpdateWithoutConnectionsSentInput>
  }

  export type UserUpdateOneRequiredWithoutConnectionsReceivedNestedInput = {
    create?: XOR<UserCreateWithoutConnectionsReceivedInput, UserUncheckedCreateWithoutConnectionsReceivedInput>
    connectOrCreate?: UserCreateOrConnectWithoutConnectionsReceivedInput
    upsert?: UserUpsertWithoutConnectionsReceivedInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutConnectionsReceivedInput, UserUpdateWithoutConnectionsReceivedInput>, UserUncheckedUpdateWithoutConnectionsReceivedInput>
  }

  export type UserCreateNestedOneWithoutMessagesSentInput = {
    create?: XOR<UserCreateWithoutMessagesSentInput, UserUncheckedCreateWithoutMessagesSentInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesSentInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutMessagesReceivedInput = {
    create?: XOR<UserCreateWithoutMessagesReceivedInput, UserUncheckedCreateWithoutMessagesReceivedInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesReceivedInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutMessagesSentNestedInput = {
    create?: XOR<UserCreateWithoutMessagesSentInput, UserUncheckedCreateWithoutMessagesSentInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesSentInput
    upsert?: UserUpsertWithoutMessagesSentInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutMessagesSentInput, UserUpdateWithoutMessagesSentInput>, UserUncheckedUpdateWithoutMessagesSentInput>
  }

  export type UserUpdateOneRequiredWithoutMessagesReceivedNestedInput = {
    create?: XOR<UserCreateWithoutMessagesReceivedInput, UserUncheckedCreateWithoutMessagesReceivedInput>
    connectOrCreate?: UserCreateOrConnectWithoutMessagesReceivedInput
    upsert?: UserUpsertWithoutMessagesReceivedInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutMessagesReceivedInput, UserUpdateWithoutMessagesReceivedInput>, UserUncheckedUpdateWithoutMessagesReceivedInput>
  }

  export type OpportunityCreateactivitiesFamiliesInput = {
    set: string[]
  }

  export type OpportunityCreateactivitiesInput = {
    set: string[]
  }

  export type UserCreateNestedOneWithoutOpportunitiesInput = {
    create?: XOR<UserCreateWithoutOpportunitiesInput, UserUncheckedCreateWithoutOpportunitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunitiesInput
    connect?: UserWhereUniqueInput
  }

  export type OpportunityLikeCreateNestedManyWithoutOpportunityInput = {
    create?: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput> | OpportunityLikeCreateWithoutOpportunityInput[] | OpportunityLikeUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutOpportunityInput | OpportunityLikeCreateOrConnectWithoutOpportunityInput[]
    createMany?: OpportunityLikeCreateManyOpportunityInputEnvelope
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
  }

  export type OpportunityCommentCreateNestedManyWithoutOpportunityInput = {
    create?: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput> | OpportunityCommentCreateWithoutOpportunityInput[] | OpportunityCommentUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutOpportunityInput | OpportunityCommentCreateOrConnectWithoutOpportunityInput[]
    createMany?: OpportunityCommentCreateManyOpportunityInputEnvelope
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
  }

  export type OpportunityLikeUncheckedCreateNestedManyWithoutOpportunityInput = {
    create?: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput> | OpportunityLikeCreateWithoutOpportunityInput[] | OpportunityLikeUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutOpportunityInput | OpportunityLikeCreateOrConnectWithoutOpportunityInput[]
    createMany?: OpportunityLikeCreateManyOpportunityInputEnvelope
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
  }

  export type OpportunityCommentUncheckedCreateNestedManyWithoutOpportunityInput = {
    create?: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput> | OpportunityCommentCreateWithoutOpportunityInput[] | OpportunityCommentUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutOpportunityInput | OpportunityCommentCreateOrConnectWithoutOpportunityInput[]
    createMany?: OpportunityCommentCreateManyOpportunityInputEnvelope
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
  }

  export type OpportunityUpdateactivitiesFamiliesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type OpportunityUpdateactivitiesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type UserUpdateOneRequiredWithoutOpportunitiesNestedInput = {
    create?: XOR<UserCreateWithoutOpportunitiesInput, UserUncheckedCreateWithoutOpportunitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunitiesInput
    upsert?: UserUpsertWithoutOpportunitiesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOpportunitiesInput, UserUpdateWithoutOpportunitiesInput>, UserUncheckedUpdateWithoutOpportunitiesInput>
  }

  export type OpportunityLikeUpdateManyWithoutOpportunityNestedInput = {
    create?: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput> | OpportunityLikeCreateWithoutOpportunityInput[] | OpportunityLikeUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutOpportunityInput | OpportunityLikeCreateOrConnectWithoutOpportunityInput[]
    upsert?: OpportunityLikeUpsertWithWhereUniqueWithoutOpportunityInput | OpportunityLikeUpsertWithWhereUniqueWithoutOpportunityInput[]
    createMany?: OpportunityLikeCreateManyOpportunityInputEnvelope
    set?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    disconnect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    delete?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    update?: OpportunityLikeUpdateWithWhereUniqueWithoutOpportunityInput | OpportunityLikeUpdateWithWhereUniqueWithoutOpportunityInput[]
    updateMany?: OpportunityLikeUpdateManyWithWhereWithoutOpportunityInput | OpportunityLikeUpdateManyWithWhereWithoutOpportunityInput[]
    deleteMany?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
  }

  export type OpportunityCommentUpdateManyWithoutOpportunityNestedInput = {
    create?: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput> | OpportunityCommentCreateWithoutOpportunityInput[] | OpportunityCommentUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutOpportunityInput | OpportunityCommentCreateOrConnectWithoutOpportunityInput[]
    upsert?: OpportunityCommentUpsertWithWhereUniqueWithoutOpportunityInput | OpportunityCommentUpsertWithWhereUniqueWithoutOpportunityInput[]
    createMany?: OpportunityCommentCreateManyOpportunityInputEnvelope
    set?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    disconnect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    delete?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    update?: OpportunityCommentUpdateWithWhereUniqueWithoutOpportunityInput | OpportunityCommentUpdateWithWhereUniqueWithoutOpportunityInput[]
    updateMany?: OpportunityCommentUpdateManyWithWhereWithoutOpportunityInput | OpportunityCommentUpdateManyWithWhereWithoutOpportunityInput[]
    deleteMany?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
  }

  export type OpportunityLikeUncheckedUpdateManyWithoutOpportunityNestedInput = {
    create?: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput> | OpportunityLikeCreateWithoutOpportunityInput[] | OpportunityLikeUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityLikeCreateOrConnectWithoutOpportunityInput | OpportunityLikeCreateOrConnectWithoutOpportunityInput[]
    upsert?: OpportunityLikeUpsertWithWhereUniqueWithoutOpportunityInput | OpportunityLikeUpsertWithWhereUniqueWithoutOpportunityInput[]
    createMany?: OpportunityLikeCreateManyOpportunityInputEnvelope
    set?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    disconnect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    delete?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    connect?: OpportunityLikeWhereUniqueInput | OpportunityLikeWhereUniqueInput[]
    update?: OpportunityLikeUpdateWithWhereUniqueWithoutOpportunityInput | OpportunityLikeUpdateWithWhereUniqueWithoutOpportunityInput[]
    updateMany?: OpportunityLikeUpdateManyWithWhereWithoutOpportunityInput | OpportunityLikeUpdateManyWithWhereWithoutOpportunityInput[]
    deleteMany?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
  }

  export type OpportunityCommentUncheckedUpdateManyWithoutOpportunityNestedInput = {
    create?: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput> | OpportunityCommentCreateWithoutOpportunityInput[] | OpportunityCommentUncheckedCreateWithoutOpportunityInput[]
    connectOrCreate?: OpportunityCommentCreateOrConnectWithoutOpportunityInput | OpportunityCommentCreateOrConnectWithoutOpportunityInput[]
    upsert?: OpportunityCommentUpsertWithWhereUniqueWithoutOpportunityInput | OpportunityCommentUpsertWithWhereUniqueWithoutOpportunityInput[]
    createMany?: OpportunityCommentCreateManyOpportunityInputEnvelope
    set?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    disconnect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    delete?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    connect?: OpportunityCommentWhereUniqueInput | OpportunityCommentWhereUniqueInput[]
    update?: OpportunityCommentUpdateWithWhereUniqueWithoutOpportunityInput | OpportunityCommentUpdateWithWhereUniqueWithoutOpportunityInput[]
    updateMany?: OpportunityCommentUpdateManyWithWhereWithoutOpportunityInput | OpportunityCommentUpdateManyWithWhereWithoutOpportunityInput[]
    deleteMany?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutOpportunityLikesInput = {
    create?: XOR<UserCreateWithoutOpportunityLikesInput, UserUncheckedCreateWithoutOpportunityLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunityLikesInput
    connect?: UserWhereUniqueInput
  }

  export type OpportunityCreateNestedOneWithoutLikesInput = {
    create?: XOR<OpportunityCreateWithoutLikesInput, OpportunityUncheckedCreateWithoutLikesInput>
    connectOrCreate?: OpportunityCreateOrConnectWithoutLikesInput
    connect?: OpportunityWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutOpportunityLikesNestedInput = {
    create?: XOR<UserCreateWithoutOpportunityLikesInput, UserUncheckedCreateWithoutOpportunityLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunityLikesInput
    upsert?: UserUpsertWithoutOpportunityLikesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOpportunityLikesInput, UserUpdateWithoutOpportunityLikesInput>, UserUncheckedUpdateWithoutOpportunityLikesInput>
  }

  export type OpportunityUpdateOneRequiredWithoutLikesNestedInput = {
    create?: XOR<OpportunityCreateWithoutLikesInput, OpportunityUncheckedCreateWithoutLikesInput>
    connectOrCreate?: OpportunityCreateOrConnectWithoutLikesInput
    upsert?: OpportunityUpsertWithoutLikesInput
    connect?: OpportunityWhereUniqueInput
    update?: XOR<XOR<OpportunityUpdateToOneWithWhereWithoutLikesInput, OpportunityUpdateWithoutLikesInput>, OpportunityUncheckedUpdateWithoutLikesInput>
  }

  export type UserCreateNestedOneWithoutOpportunityCommentsInput = {
    create?: XOR<UserCreateWithoutOpportunityCommentsInput, UserUncheckedCreateWithoutOpportunityCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunityCommentsInput
    connect?: UserWhereUniqueInput
  }

  export type OpportunityCreateNestedOneWithoutCommentsInput = {
    create?: XOR<OpportunityCreateWithoutCommentsInput, OpportunityUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: OpportunityCreateOrConnectWithoutCommentsInput
    connect?: OpportunityWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutOpportunityCommentsNestedInput = {
    create?: XOR<UserCreateWithoutOpportunityCommentsInput, UserUncheckedCreateWithoutOpportunityCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutOpportunityCommentsInput
    upsert?: UserUpsertWithoutOpportunityCommentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOpportunityCommentsInput, UserUpdateWithoutOpportunityCommentsInput>, UserUncheckedUpdateWithoutOpportunityCommentsInput>
  }

  export type OpportunityUpdateOneRequiredWithoutCommentsNestedInput = {
    create?: XOR<OpportunityCreateWithoutCommentsInput, OpportunityUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: OpportunityCreateOrConnectWithoutCommentsInput
    upsert?: OpportunityUpsertWithoutCommentsInput
    connect?: OpportunityWhereUniqueInput
    update?: XOR<XOR<OpportunityUpdateToOneWithWhereWithoutCommentsInput, OpportunityUpdateWithoutCommentsInput>, OpportunityUncheckedUpdateWithoutCommentsInput>
  }

  export type EventCreateimagesInput = {
    set: string[]
  }

  export type EventLikeCreateNestedManyWithoutEventInput = {
    create?: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput> | EventLikeCreateWithoutEventInput[] | EventLikeUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutEventInput | EventLikeCreateOrConnectWithoutEventInput[]
    createMany?: EventLikeCreateManyEventInputEnvelope
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
  }

  export type EventCommentCreateNestedManyWithoutEventInput = {
    create?: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput> | EventCommentCreateWithoutEventInput[] | EventCommentUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutEventInput | EventCommentCreateOrConnectWithoutEventInput[]
    createMany?: EventCommentCreateManyEventInputEnvelope
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
  }

  export type EventLikeUncheckedCreateNestedManyWithoutEventInput = {
    create?: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput> | EventLikeCreateWithoutEventInput[] | EventLikeUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutEventInput | EventLikeCreateOrConnectWithoutEventInput[]
    createMany?: EventLikeCreateManyEventInputEnvelope
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
  }

  export type EventCommentUncheckedCreateNestedManyWithoutEventInput = {
    create?: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput> | EventCommentCreateWithoutEventInput[] | EventCommentUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutEventInput | EventCommentCreateOrConnectWithoutEventInput[]
    createMany?: EventCommentCreateManyEventInputEnvelope
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
  }

  export type EventUpdateimagesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type EventLikeUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput> | EventLikeCreateWithoutEventInput[] | EventLikeUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutEventInput | EventLikeCreateOrConnectWithoutEventInput[]
    upsert?: EventLikeUpsertWithWhereUniqueWithoutEventInput | EventLikeUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventLikeCreateManyEventInputEnvelope
    set?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    disconnect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    delete?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    update?: EventLikeUpdateWithWhereUniqueWithoutEventInput | EventLikeUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventLikeUpdateManyWithWhereWithoutEventInput | EventLikeUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
  }

  export type EventCommentUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput> | EventCommentCreateWithoutEventInput[] | EventCommentUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutEventInput | EventCommentCreateOrConnectWithoutEventInput[]
    upsert?: EventCommentUpsertWithWhereUniqueWithoutEventInput | EventCommentUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventCommentCreateManyEventInputEnvelope
    set?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    disconnect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    delete?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    update?: EventCommentUpdateWithWhereUniqueWithoutEventInput | EventCommentUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventCommentUpdateManyWithWhereWithoutEventInput | EventCommentUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
  }

  export type EventLikeUncheckedUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput> | EventLikeCreateWithoutEventInput[] | EventLikeUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventLikeCreateOrConnectWithoutEventInput | EventLikeCreateOrConnectWithoutEventInput[]
    upsert?: EventLikeUpsertWithWhereUniqueWithoutEventInput | EventLikeUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventLikeCreateManyEventInputEnvelope
    set?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    disconnect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    delete?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    connect?: EventLikeWhereUniqueInput | EventLikeWhereUniqueInput[]
    update?: EventLikeUpdateWithWhereUniqueWithoutEventInput | EventLikeUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventLikeUpdateManyWithWhereWithoutEventInput | EventLikeUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
  }

  export type EventCommentUncheckedUpdateManyWithoutEventNestedInput = {
    create?: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput> | EventCommentCreateWithoutEventInput[] | EventCommentUncheckedCreateWithoutEventInput[]
    connectOrCreate?: EventCommentCreateOrConnectWithoutEventInput | EventCommentCreateOrConnectWithoutEventInput[]
    upsert?: EventCommentUpsertWithWhereUniqueWithoutEventInput | EventCommentUpsertWithWhereUniqueWithoutEventInput[]
    createMany?: EventCommentCreateManyEventInputEnvelope
    set?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    disconnect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    delete?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    connect?: EventCommentWhereUniqueInput | EventCommentWhereUniqueInput[]
    update?: EventCommentUpdateWithWhereUniqueWithoutEventInput | EventCommentUpdateWithWhereUniqueWithoutEventInput[]
    updateMany?: EventCommentUpdateManyWithWhereWithoutEventInput | EventCommentUpdateManyWithWhereWithoutEventInput[]
    deleteMany?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutEventLikesInput = {
    create?: XOR<UserCreateWithoutEventLikesInput, UserUncheckedCreateWithoutEventLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutEventLikesInput
    connect?: UserWhereUniqueInput
  }

  export type EventCreateNestedOneWithoutLikesInput = {
    create?: XOR<EventCreateWithoutLikesInput, EventUncheckedCreateWithoutLikesInput>
    connectOrCreate?: EventCreateOrConnectWithoutLikesInput
    connect?: EventWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutEventLikesNestedInput = {
    create?: XOR<UserCreateWithoutEventLikesInput, UserUncheckedCreateWithoutEventLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutEventLikesInput
    upsert?: UserUpsertWithoutEventLikesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEventLikesInput, UserUpdateWithoutEventLikesInput>, UserUncheckedUpdateWithoutEventLikesInput>
  }

  export type EventUpdateOneRequiredWithoutLikesNestedInput = {
    create?: XOR<EventCreateWithoutLikesInput, EventUncheckedCreateWithoutLikesInput>
    connectOrCreate?: EventCreateOrConnectWithoutLikesInput
    upsert?: EventUpsertWithoutLikesInput
    connect?: EventWhereUniqueInput
    update?: XOR<XOR<EventUpdateToOneWithWhereWithoutLikesInput, EventUpdateWithoutLikesInput>, EventUncheckedUpdateWithoutLikesInput>
  }

  export type UserCreateNestedOneWithoutEventCommentsInput = {
    create?: XOR<UserCreateWithoutEventCommentsInput, UserUncheckedCreateWithoutEventCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEventCommentsInput
    connect?: UserWhereUniqueInput
  }

  export type EventCreateNestedOneWithoutCommentsInput = {
    create?: XOR<EventCreateWithoutCommentsInput, EventUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: EventCreateOrConnectWithoutCommentsInput
    connect?: EventWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutEventCommentsNestedInput = {
    create?: XOR<UserCreateWithoutEventCommentsInput, UserUncheckedCreateWithoutEventCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutEventCommentsInput
    upsert?: UserUpsertWithoutEventCommentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEventCommentsInput, UserUpdateWithoutEventCommentsInput>, UserUncheckedUpdateWithoutEventCommentsInput>
  }

  export type EventUpdateOneRequiredWithoutCommentsNestedInput = {
    create?: XOR<EventCreateWithoutCommentsInput, EventUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: EventCreateOrConnectWithoutCommentsInput
    upsert?: EventUpsertWithoutCommentsInput
    connect?: EventWhereUniqueInput
    update?: XOR<XOR<EventUpdateToOneWithWhereWithoutCommentsInput, EventUpdateWithoutCommentsInput>, EventUncheckedUpdateWithoutCommentsInput>
  }

  export type AppointmentCreateimagesInput = {
    set: string[]
  }

  export type AppointmentLikeCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput> | AppointmentLikeCreateWithoutAppointmentInput[] | AppointmentLikeUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutAppointmentInput | AppointmentLikeCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentLikeCreateManyAppointmentInputEnvelope
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
  }

  export type AppointmentCommentCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput> | AppointmentCommentCreateWithoutAppointmentInput[] | AppointmentCommentUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutAppointmentInput | AppointmentCommentCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentCommentCreateManyAppointmentInputEnvelope
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
  }

  export type AppointmentRegistrationCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput> | AppointmentRegistrationCreateWithoutAppointmentInput[] | AppointmentRegistrationUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutAppointmentInput | AppointmentRegistrationCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentRegistrationCreateManyAppointmentInputEnvelope
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
  }

  export type AppointmentLikeUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput> | AppointmentLikeCreateWithoutAppointmentInput[] | AppointmentLikeUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutAppointmentInput | AppointmentLikeCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentLikeCreateManyAppointmentInputEnvelope
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
  }

  export type AppointmentCommentUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput> | AppointmentCommentCreateWithoutAppointmentInput[] | AppointmentCommentUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutAppointmentInput | AppointmentCommentCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentCommentCreateManyAppointmentInputEnvelope
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
  }

  export type AppointmentRegistrationUncheckedCreateNestedManyWithoutAppointmentInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput> | AppointmentRegistrationCreateWithoutAppointmentInput[] | AppointmentRegistrationUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutAppointmentInput | AppointmentRegistrationCreateOrConnectWithoutAppointmentInput[]
    createMany?: AppointmentRegistrationCreateManyAppointmentInputEnvelope
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
  }

  export type AppointmentUpdateimagesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type AppointmentLikeUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput> | AppointmentLikeCreateWithoutAppointmentInput[] | AppointmentLikeUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutAppointmentInput | AppointmentLikeCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentLikeUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentLikeUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentLikeCreateManyAppointmentInputEnvelope
    set?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    disconnect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    delete?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    update?: AppointmentLikeUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentLikeUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentLikeUpdateManyWithWhereWithoutAppointmentInput | AppointmentLikeUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
  }

  export type AppointmentCommentUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput> | AppointmentCommentCreateWithoutAppointmentInput[] | AppointmentCommentUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutAppointmentInput | AppointmentCommentCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentCommentUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentCommentUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentCommentCreateManyAppointmentInputEnvelope
    set?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    disconnect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    delete?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    update?: AppointmentCommentUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentCommentUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentCommentUpdateManyWithWhereWithoutAppointmentInput | AppointmentCommentUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
  }

  export type AppointmentRegistrationUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput> | AppointmentRegistrationCreateWithoutAppointmentInput[] | AppointmentRegistrationUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutAppointmentInput | AppointmentRegistrationCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentRegistrationUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentRegistrationUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentRegistrationCreateManyAppointmentInputEnvelope
    set?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    disconnect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    delete?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    update?: AppointmentRegistrationUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentRegistrationUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentRegistrationUpdateManyWithWhereWithoutAppointmentInput | AppointmentRegistrationUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
  }

  export type AppointmentLikeUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput> | AppointmentLikeCreateWithoutAppointmentInput[] | AppointmentLikeUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentLikeCreateOrConnectWithoutAppointmentInput | AppointmentLikeCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentLikeUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentLikeUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentLikeCreateManyAppointmentInputEnvelope
    set?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    disconnect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    delete?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    connect?: AppointmentLikeWhereUniqueInput | AppointmentLikeWhereUniqueInput[]
    update?: AppointmentLikeUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentLikeUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentLikeUpdateManyWithWhereWithoutAppointmentInput | AppointmentLikeUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
  }

  export type AppointmentCommentUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput> | AppointmentCommentCreateWithoutAppointmentInput[] | AppointmentCommentUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentCommentCreateOrConnectWithoutAppointmentInput | AppointmentCommentCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentCommentUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentCommentUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentCommentCreateManyAppointmentInputEnvelope
    set?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    disconnect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    delete?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    connect?: AppointmentCommentWhereUniqueInput | AppointmentCommentWhereUniqueInput[]
    update?: AppointmentCommentUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentCommentUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentCommentUpdateManyWithWhereWithoutAppointmentInput | AppointmentCommentUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
  }

  export type AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentNestedInput = {
    create?: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput> | AppointmentRegistrationCreateWithoutAppointmentInput[] | AppointmentRegistrationUncheckedCreateWithoutAppointmentInput[]
    connectOrCreate?: AppointmentRegistrationCreateOrConnectWithoutAppointmentInput | AppointmentRegistrationCreateOrConnectWithoutAppointmentInput[]
    upsert?: AppointmentRegistrationUpsertWithWhereUniqueWithoutAppointmentInput | AppointmentRegistrationUpsertWithWhereUniqueWithoutAppointmentInput[]
    createMany?: AppointmentRegistrationCreateManyAppointmentInputEnvelope
    set?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    disconnect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    delete?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    connect?: AppointmentRegistrationWhereUniqueInput | AppointmentRegistrationWhereUniqueInput[]
    update?: AppointmentRegistrationUpdateWithWhereUniqueWithoutAppointmentInput | AppointmentRegistrationUpdateWithWhereUniqueWithoutAppointmentInput[]
    updateMany?: AppointmentRegistrationUpdateManyWithWhereWithoutAppointmentInput | AppointmentRegistrationUpdateManyWithWhereWithoutAppointmentInput[]
    deleteMany?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutAppointmentLikesInput = {
    create?: XOR<UserCreateWithoutAppointmentLikesInput, UserUncheckedCreateWithoutAppointmentLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentLikesInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentCreateNestedOneWithoutLikesInput = {
    create?: XOR<AppointmentCreateWithoutLikesInput, AppointmentUncheckedCreateWithoutLikesInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutLikesInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutAppointmentLikesNestedInput = {
    create?: XOR<UserCreateWithoutAppointmentLikesInput, UserUncheckedCreateWithoutAppointmentLikesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentLikesInput
    upsert?: UserUpsertWithoutAppointmentLikesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAppointmentLikesInput, UserUpdateWithoutAppointmentLikesInput>, UserUncheckedUpdateWithoutAppointmentLikesInput>
  }

  export type AppointmentUpdateOneRequiredWithoutLikesNestedInput = {
    create?: XOR<AppointmentCreateWithoutLikesInput, AppointmentUncheckedCreateWithoutLikesInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutLikesInput
    upsert?: AppointmentUpsertWithoutLikesInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutLikesInput, AppointmentUpdateWithoutLikesInput>, AppointmentUncheckedUpdateWithoutLikesInput>
  }

  export type UserCreateNestedOneWithoutAppointmentCommentsInput = {
    create?: XOR<UserCreateWithoutAppointmentCommentsInput, UserUncheckedCreateWithoutAppointmentCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentCommentsInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentCreateNestedOneWithoutCommentsInput = {
    create?: XOR<AppointmentCreateWithoutCommentsInput, AppointmentUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutCommentsInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutAppointmentCommentsNestedInput = {
    create?: XOR<UserCreateWithoutAppointmentCommentsInput, UserUncheckedCreateWithoutAppointmentCommentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentCommentsInput
    upsert?: UserUpsertWithoutAppointmentCommentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAppointmentCommentsInput, UserUpdateWithoutAppointmentCommentsInput>, UserUncheckedUpdateWithoutAppointmentCommentsInput>
  }

  export type AppointmentUpdateOneRequiredWithoutCommentsNestedInput = {
    create?: XOR<AppointmentCreateWithoutCommentsInput, AppointmentUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutCommentsInput
    upsert?: AppointmentUpsertWithoutCommentsInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutCommentsInput, AppointmentUpdateWithoutCommentsInput>, AppointmentUncheckedUpdateWithoutCommentsInput>
  }

  export type UserCreateNestedOneWithoutAppointmentsRegistrationsInput = {
    create?: XOR<UserCreateWithoutAppointmentsRegistrationsInput, UserUncheckedCreateWithoutAppointmentsRegistrationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentsRegistrationsInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentCreateNestedOneWithoutRegistrationsInput = {
    create?: XOR<AppointmentCreateWithoutRegistrationsInput, AppointmentUncheckedCreateWithoutRegistrationsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutRegistrationsInput
    connect?: AppointmentWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutAppointmentsRegistrationsNestedInput = {
    create?: XOR<UserCreateWithoutAppointmentsRegistrationsInput, UserUncheckedCreateWithoutAppointmentsRegistrationsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAppointmentsRegistrationsInput
    upsert?: UserUpsertWithoutAppointmentsRegistrationsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAppointmentsRegistrationsInput, UserUpdateWithoutAppointmentsRegistrationsInput>, UserUncheckedUpdateWithoutAppointmentsRegistrationsInput>
  }

  export type AppointmentUpdateOneRequiredWithoutRegistrationsNestedInput = {
    create?: XOR<AppointmentCreateWithoutRegistrationsInput, AppointmentUncheckedCreateWithoutRegistrationsInput>
    connectOrCreate?: AppointmentCreateOrConnectWithoutRegistrationsInput
    upsert?: AppointmentUpsertWithoutRegistrationsInput
    connect?: AppointmentWhereUniqueInput
    update?: XOR<XOR<AppointmentUpdateToOneWithWhereWithoutRegistrationsInput, AppointmentUpdateWithoutRegistrationsInput>, AppointmentUncheckedUpdateWithoutRegistrationsInput>
  }

  export type AlbumCreateimagesInput = {
    set: string[]
  }

  export type AlbumUpdateimagesInput = {
    set?: string[]
    push?: string | string[]
  }

  export type CategoryCreateNestedOneWithoutEditionsInput = {
    create?: XOR<CategoryCreateWithoutEditionsInput, CategoryUncheckedCreateWithoutEditionsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutEditionsInput
    connect?: CategoryWhereUniqueInput
  }

  export type CategoryUpdateOneRequiredWithoutEditionsNestedInput = {
    create?: XOR<CategoryCreateWithoutEditionsInput, CategoryUncheckedCreateWithoutEditionsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutEditionsInput
    upsert?: CategoryUpsertWithoutEditionsInput
    connect?: CategoryWhereUniqueInput
    update?: XOR<XOR<CategoryUpdateToOneWithWhereWithoutEditionsInput, CategoryUpdateWithoutEditionsInput>, CategoryUncheckedUpdateWithoutEditionsInput>
  }

  export type EnumTrainingTypeFieldUpdateOperationsInput = {
    set?: $Enums.TrainingType
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type 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 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 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 NestedEnumCivilityFilter<$PrismaModel = never> = {
    equals?: $Enums.Civility | EnumCivilityFieldRefInput<$PrismaModel>
    in?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    notIn?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    not?: NestedEnumCivilityFilter<$PrismaModel> | $Enums.Civility
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedEnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  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 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 NestedEnumCivilityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Civility | EnumCivilityFieldRefInput<$PrismaModel>
    in?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    notIn?: $Enums.Civility[] | ListEnumCivilityFieldRefInput<$PrismaModel>
    not?: NestedEnumCivilityWithAggregatesFilter<$PrismaModel> | $Enums.Civility
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCivilityFilter<$PrismaModel>
    _max?: NestedEnumCivilityFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedEnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$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 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 NestedEnumSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.Source | EnumSourceFieldRefInput<$PrismaModel>
    in?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumSourceFilter<$PrismaModel> | $Enums.Source
  }

  export type NestedEnumSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Source | EnumSourceFieldRefInput<$PrismaModel>
    in?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.Source[] | ListEnumSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumSourceWithAggregatesFilter<$PrismaModel> | $Enums.Source
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSourceFilter<$PrismaModel>
    _max?: NestedEnumSourceFilter<$PrismaModel>
  }

  export type NestedEnumLegalFormFilter<$PrismaModel = never> = {
    equals?: $Enums.LegalForm | EnumLegalFormFieldRefInput<$PrismaModel>
    in?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    notIn?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    not?: NestedEnumLegalFormFilter<$PrismaModel> | $Enums.LegalForm
  }

  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 NestedEnumLegalFormWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LegalForm | EnumLegalFormFieldRefInput<$PrismaModel>
    in?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    notIn?: $Enums.LegalForm[] | ListEnumLegalFormFieldRefInput<$PrismaModel>
    not?: NestedEnumLegalFormWithAggregatesFilter<$PrismaModel> | $Enums.LegalForm
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLegalFormFilter<$PrismaModel>
    _max?: NestedEnumLegalFormFilter<$PrismaModel>
  }

  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedEnumTrainingTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.TrainingType | EnumTrainingTypeFieldRefInput<$PrismaModel>
    in?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTrainingTypeFilter<$PrismaModel> | $Enums.TrainingType
  }

  export type NestedEnumTrainingTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.TrainingType | EnumTrainingTypeFieldRefInput<$PrismaModel>
    in?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.TrainingType[] | ListEnumTrainingTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTrainingTypeWithAggregatesFilter<$PrismaModel> | $Enums.TrainingType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTrainingTypeFilter<$PrismaModel>
    _max?: NestedEnumTrainingTypeFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }
  export type NestedJsonNullableFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type CompanyCreateWithoutTurnoverInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutCompaniesInput
    contactPosition?: PositionCreateNestedOneWithoutCompaniesInput
    nEmployees?: NEmployeesCreateNestedOneWithoutCompaniesInput
    users?: UserCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUncheckedCreateWithoutTurnoverInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutCompanyInput
  }

  export type CompanyCreateOrConnectWithoutTurnoverInput = {
    where: CompanyWhereUniqueInput
    create: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput>
  }

  export type CompanyCreateManyTurnoverInputEnvelope = {
    data: CompanyCreateManyTurnoverInput | CompanyCreateManyTurnoverInput[]
    skipDuplicates?: boolean
  }

  export type CompanyUpsertWithWhereUniqueWithoutTurnoverInput = {
    where: CompanyWhereUniqueInput
    update: XOR<CompanyUpdateWithoutTurnoverInput, CompanyUncheckedUpdateWithoutTurnoverInput>
    create: XOR<CompanyCreateWithoutTurnoverInput, CompanyUncheckedCreateWithoutTurnoverInput>
  }

  export type CompanyUpdateWithWhereUniqueWithoutTurnoverInput = {
    where: CompanyWhereUniqueInput
    data: XOR<CompanyUpdateWithoutTurnoverInput, CompanyUncheckedUpdateWithoutTurnoverInput>
  }

  export type CompanyUpdateManyWithWhereWithoutTurnoverInput = {
    where: CompanyScalarWhereInput
    data: XOR<CompanyUpdateManyMutationInput, CompanyUncheckedUpdateManyWithoutTurnoverInput>
  }

  export type CompanyScalarWhereInput = {
    AND?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
    OR?: CompanyScalarWhereInput[]
    NOT?: CompanyScalarWhereInput | CompanyScalarWhereInput[]
    id?: StringFilter<"Company"> | string
    logo?: StringNullableFilter<"Company"> | string | null
    name?: StringFilter<"Company"> | string
    legalForm?: EnumLegalFormFilter<"Company"> | $Enums.LegalForm
    cityId?: StringNullableFilter<"Company"> | string | null
    address?: StringFilter<"Company"> | string
    phoneNumber?: StringFilter<"Company"> | string
    fax?: StringFilter<"Company"> | string
    email?: StringFilter<"Company"> | string
    website?: StringFilter<"Company"> | string
    linkedin?: StringFilter<"Company"> | string
    facebook?: StringFilter<"Company"> | string
    contactFirstName?: StringFilter<"Company"> | string
    contactLastName?: StringFilter<"Company"> | string
    contactEmail?: StringFilter<"Company"> | string
    contactPositionId?: StringNullableFilter<"Company"> | string | null
    contactLinkedin?: StringFilter<"Company"> | string
    contactFacebook?: StringFilter<"Company"> | string
    businessLicense?: StringFilter<"Company"> | string
    numRC?: StringFilter<"Company"> | string
    numICE?: StringFilter<"Company"> | string
    capital?: FloatNullableFilter<"Company"> | number | null
    turnoverId?: StringNullableFilter<"Company"> | string | null
    nEmployeesId?: StringNullableFilter<"Company"> | string | null
    activitiesFamilies?: StringNullableListFilter<"Company">
    activities?: StringNullableListFilter<"Company">
    importCountries?: StringNullableListFilter<"Company">
    exportCountries?: StringNullableListFilter<"Company">
    verified?: BoolFilter<"Company"> | boolean
    active?: BoolFilter<"Company"> | boolean
    partner?: BoolFilter<"Company"> | boolean
    contributor?: BoolFilter<"Company"> | boolean
    createdAt?: DateTimeFilter<"Company"> | Date | string
  }

  export type CompanyCreateWithoutNEmployeesInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutCompaniesInput
    contactPosition?: PositionCreateNestedOneWithoutCompaniesInput
    turnover?: TurnoverCreateNestedOneWithoutCompaniesInput
    users?: UserCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUncheckedCreateWithoutNEmployeesInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutCompanyInput
  }

  export type CompanyCreateOrConnectWithoutNEmployeesInput = {
    where: CompanyWhereUniqueInput
    create: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput>
  }

  export type CompanyCreateManyNEmployeesInputEnvelope = {
    data: CompanyCreateManyNEmployeesInput | CompanyCreateManyNEmployeesInput[]
    skipDuplicates?: boolean
  }

  export type CompanyUpsertWithWhereUniqueWithoutNEmployeesInput = {
    where: CompanyWhereUniqueInput
    update: XOR<CompanyUpdateWithoutNEmployeesInput, CompanyUncheckedUpdateWithoutNEmployeesInput>
    create: XOR<CompanyCreateWithoutNEmployeesInput, CompanyUncheckedCreateWithoutNEmployeesInput>
  }

  export type CompanyUpdateWithWhereUniqueWithoutNEmployeesInput = {
    where: CompanyWhereUniqueInput
    data: XOR<CompanyUpdateWithoutNEmployeesInput, CompanyUncheckedUpdateWithoutNEmployeesInput>
  }

  export type CompanyUpdateManyWithWhereWithoutNEmployeesInput = {
    where: CompanyScalarWhereInput
    data: XOR<CompanyUpdateManyMutationInput, CompanyUncheckedUpdateManyWithoutNEmployeesInput>
  }

  export type UserCreateWithoutCityInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCityInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCityInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput>
  }

  export type UserCreateManyCityInputEnvelope = {
    data: UserCreateManyCityInput | UserCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type CompanyCreateWithoutCityInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    contactPosition?: PositionCreateNestedOneWithoutCompaniesInput
    turnover?: TurnoverCreateNestedOneWithoutCompaniesInput
    nEmployees?: NEmployeesCreateNestedOneWithoutCompaniesInput
    users?: UserCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUncheckedCreateWithoutCityInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutCompanyInput
  }

  export type CompanyCreateOrConnectWithoutCityInput = {
    where: CompanyWhereUniqueInput
    create: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput>
  }

  export type CompanyCreateManyCityInputEnvelope = {
    data: CompanyCreateManyCityInput | CompanyCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithWhereUniqueWithoutCityInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutCityInput, UserUncheckedUpdateWithoutCityInput>
    create: XOR<UserCreateWithoutCityInput, UserUncheckedCreateWithoutCityInput>
  }

  export type UserUpdateWithWhereUniqueWithoutCityInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutCityInput, UserUncheckedUpdateWithoutCityInput>
  }

  export type UserUpdateManyWithWhereWithoutCityInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutCityInput>
  }

  export type UserScalarWhereInput = {
    AND?: UserScalarWhereInput | UserScalarWhereInput[]
    OR?: UserScalarWhereInput[]
    NOT?: UserScalarWhereInput | UserScalarWhereInput[]
    id?: StringFilter<"User"> | string
    civility?: EnumCivilityFilter<"User"> | $Enums.Civility
    firstName?: StringFilter<"User"> | string
    lastName?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    cityId?: StringNullableFilter<"User"> | string | null
    positionId?: StringNullableFilter<"User"> | string | null
    phoneNumber?: StringFilter<"User"> | string
    expertiseAreas?: StringNullableListFilter<"User">
    interestAreas?: StringNullableListFilter<"User">
    bio?: StringFilter<"User"> | string
    companyId?: StringNullableFilter<"User"> | string | null
    department?: StringNullableFilter<"User"> | string | null
    service?: StringNullableFilter<"User"> | string | null
    adresse?: StringNullableFilter<"User"> | string | null
    collegeId?: StringNullableFilter<"User"> | string | null
    provinceId?: StringNullableFilter<"User"> | string | null
    mandateId?: StringNullableFilter<"User"> | string | null
    commissions?: StringNullableListFilter<"User">
    details?: StringNullableFilter<"User"> | string | null
    active?: BoolFilter<"User"> | boolean
    member?: BoolFilter<"User"> | boolean
    role?: EnumRoleFilter<"User"> | $Enums.Role
    permissions?: EnumPermissionNullableListFilter<"User">
    resetPasswordCode?: StringNullableFilter<"User"> | string | null
    resetPasswordAt?: DateTimeNullableFilter<"User"> | Date | string | null
    loggedInAt?: DateTimeNullableFilter<"User"> | Date | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
  }

  export type CompanyUpsertWithWhereUniqueWithoutCityInput = {
    where: CompanyWhereUniqueInput
    update: XOR<CompanyUpdateWithoutCityInput, CompanyUncheckedUpdateWithoutCityInput>
    create: XOR<CompanyCreateWithoutCityInput, CompanyUncheckedCreateWithoutCityInput>
  }

  export type CompanyUpdateWithWhereUniqueWithoutCityInput = {
    where: CompanyWhereUniqueInput
    data: XOR<CompanyUpdateWithoutCityInput, CompanyUncheckedUpdateWithoutCityInput>
  }

  export type CompanyUpdateManyWithWhereWithoutCityInput = {
    where: CompanyScalarWhereInput
    data: XOR<CompanyUpdateManyMutationInput, CompanyUncheckedUpdateManyWithoutCityInput>
  }

  export type UserCreateWithoutPositionInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPositionInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPositionInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput>
  }

  export type UserCreateManyPositionInputEnvelope = {
    data: UserCreateManyPositionInput | UserCreateManyPositionInput[]
    skipDuplicates?: boolean
  }

  export type CompanyCreateWithoutContactPositionInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutCompaniesInput
    turnover?: TurnoverCreateNestedOneWithoutCompaniesInput
    nEmployees?: NEmployeesCreateNestedOneWithoutCompaniesInput
    users?: UserCreateNestedManyWithoutCompanyInput
  }

  export type CompanyUncheckedCreateWithoutContactPositionInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    users?: UserUncheckedCreateNestedManyWithoutCompanyInput
  }

  export type CompanyCreateOrConnectWithoutContactPositionInput = {
    where: CompanyWhereUniqueInput
    create: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput>
  }

  export type CompanyCreateManyContactPositionInputEnvelope = {
    data: CompanyCreateManyContactPositionInput | CompanyCreateManyContactPositionInput[]
    skipDuplicates?: boolean
  }

  export type ElectedMemberCreateWithoutPositionInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutPositionInput = {
    id?: string
    image?: string | null
    fullName: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutPositionInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput>
  }

  export type ElectedMemberCreateManyPositionInputEnvelope = {
    data: ElectedMemberCreateManyPositionInput | ElectedMemberCreateManyPositionInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithWhereUniqueWithoutPositionInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutPositionInput, UserUncheckedUpdateWithoutPositionInput>
    create: XOR<UserCreateWithoutPositionInput, UserUncheckedCreateWithoutPositionInput>
  }

  export type UserUpdateWithWhereUniqueWithoutPositionInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutPositionInput, UserUncheckedUpdateWithoutPositionInput>
  }

  export type UserUpdateManyWithWhereWithoutPositionInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutPositionInput>
  }

  export type CompanyUpsertWithWhereUniqueWithoutContactPositionInput = {
    where: CompanyWhereUniqueInput
    update: XOR<CompanyUpdateWithoutContactPositionInput, CompanyUncheckedUpdateWithoutContactPositionInput>
    create: XOR<CompanyCreateWithoutContactPositionInput, CompanyUncheckedCreateWithoutContactPositionInput>
  }

  export type CompanyUpdateWithWhereUniqueWithoutContactPositionInput = {
    where: CompanyWhereUniqueInput
    data: XOR<CompanyUpdateWithoutContactPositionInput, CompanyUncheckedUpdateWithoutContactPositionInput>
  }

  export type CompanyUpdateManyWithWhereWithoutContactPositionInput = {
    where: CompanyScalarWhereInput
    data: XOR<CompanyUpdateManyMutationInput, CompanyUncheckedUpdateManyWithoutContactPositionInput>
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutPositionInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutPositionInput, ElectedMemberUncheckedUpdateWithoutPositionInput>
    create: XOR<ElectedMemberCreateWithoutPositionInput, ElectedMemberUncheckedCreateWithoutPositionInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutPositionInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutPositionInput, ElectedMemberUncheckedUpdateWithoutPositionInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutPositionInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutPositionInput>
  }

  export type ElectedMemberScalarWhereInput = {
    AND?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
    OR?: ElectedMemberScalarWhereInput[]
    NOT?: ElectedMemberScalarWhereInput | ElectedMemberScalarWhereInput[]
    id?: StringFilter<"ElectedMember"> | string
    image?: StringNullableFilter<"ElectedMember"> | string | null
    fullName?: StringFilter<"ElectedMember"> | string
    positionId?: StringFilter<"ElectedMember"> | string
    activityFamilyId?: StringFilter<"ElectedMember"> | string
    activityId?: StringFilter<"ElectedMember"> | string
    phoneNumber?: StringFilter<"ElectedMember"> | string
    gsm?: StringFilter<"ElectedMember"> | string
    fax?: StringFilter<"ElectedMember"> | string
    email?: StringFilter<"ElectedMember"> | string
    adresse?: StringFilter<"ElectedMember"> | string
    collegeId?: StringFilter<"ElectedMember"> | string
    provinceId?: StringFilter<"ElectedMember"> | string
    mandateId?: StringFilter<"ElectedMember"> | string
    commissions?: StringNullableListFilter<"ElectedMember">
    details?: StringFilter<"ElectedMember"> | string
  }

  export type ActivityCreateWithoutActivityFamilyInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutActivityInput
  }

  export type ActivityUncheckedCreateWithoutActivityFamilyInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutActivityInput
  }

  export type ActivityCreateOrConnectWithoutActivityFamilyInput = {
    where: ActivityWhereUniqueInput
    create: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput>
  }

  export type ActivityCreateManyActivityFamilyInputEnvelope = {
    data: ActivityCreateManyActivityFamilyInput | ActivityCreateManyActivityFamilyInput[]
    skipDuplicates?: boolean
  }

  export type ElectedMemberCreateWithoutActivityFamilyInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutActivityFamilyInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutActivityFamilyInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput>
  }

  export type ElectedMemberCreateManyActivityFamilyInputEnvelope = {
    data: ElectedMemberCreateManyActivityFamilyInput | ElectedMemberCreateManyActivityFamilyInput[]
    skipDuplicates?: boolean
  }

  export type ActivityUpsertWithWhereUniqueWithoutActivityFamilyInput = {
    where: ActivityWhereUniqueInput
    update: XOR<ActivityUpdateWithoutActivityFamilyInput, ActivityUncheckedUpdateWithoutActivityFamilyInput>
    create: XOR<ActivityCreateWithoutActivityFamilyInput, ActivityUncheckedCreateWithoutActivityFamilyInput>
  }

  export type ActivityUpdateWithWhereUniqueWithoutActivityFamilyInput = {
    where: ActivityWhereUniqueInput
    data: XOR<ActivityUpdateWithoutActivityFamilyInput, ActivityUncheckedUpdateWithoutActivityFamilyInput>
  }

  export type ActivityUpdateManyWithWhereWithoutActivityFamilyInput = {
    where: ActivityScalarWhereInput
    data: XOR<ActivityUpdateManyMutationInput, ActivityUncheckedUpdateManyWithoutActivityFamilyInput>
  }

  export type ActivityScalarWhereInput = {
    AND?: ActivityScalarWhereInput | ActivityScalarWhereInput[]
    OR?: ActivityScalarWhereInput[]
    NOT?: ActivityScalarWhereInput | ActivityScalarWhereInput[]
    id?: StringFilter<"Activity"> | string
    name?: StringFilter<"Activity"> | string
    activityFamilyId?: StringFilter<"Activity"> | string
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutActivityFamilyInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutActivityFamilyInput, ElectedMemberUncheckedUpdateWithoutActivityFamilyInput>
    create: XOR<ElectedMemberCreateWithoutActivityFamilyInput, ElectedMemberUncheckedCreateWithoutActivityFamilyInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutActivityFamilyInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutActivityFamilyInput, ElectedMemberUncheckedUpdateWithoutActivityFamilyInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutActivityFamilyInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutActivityFamilyInput>
  }

  export type ActivityFamilyCreateWithoutActivitiesInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyUncheckedCreateWithoutActivitiesInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyCreateOrConnectWithoutActivitiesInput = {
    where: ActivityFamilyWhereUniqueInput
    create: XOR<ActivityFamilyCreateWithoutActivitiesInput, ActivityFamilyUncheckedCreateWithoutActivitiesInput>
  }

  export type ElectedMemberCreateWithoutActivityInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutActivityInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutActivityInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput>
  }

  export type ElectedMemberCreateManyActivityInputEnvelope = {
    data: ElectedMemberCreateManyActivityInput | ElectedMemberCreateManyActivityInput[]
    skipDuplicates?: boolean
  }

  export type ActivityFamilyUpsertWithoutActivitiesInput = {
    update: XOR<ActivityFamilyUpdateWithoutActivitiesInput, ActivityFamilyUncheckedUpdateWithoutActivitiesInput>
    create: XOR<ActivityFamilyCreateWithoutActivitiesInput, ActivityFamilyUncheckedCreateWithoutActivitiesInput>
    where?: ActivityFamilyWhereInput
  }

  export type ActivityFamilyUpdateToOneWithWhereWithoutActivitiesInput = {
    where?: ActivityFamilyWhereInput
    data: XOR<ActivityFamilyUpdateWithoutActivitiesInput, ActivityFamilyUncheckedUpdateWithoutActivitiesInput>
  }

  export type ActivityFamilyUpdateWithoutActivitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ActivityFamilyUncheckedUpdateWithoutActivitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutActivityInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutActivityInput, ElectedMemberUncheckedUpdateWithoutActivityInput>
    create: XOR<ElectedMemberCreateWithoutActivityInput, ElectedMemberUncheckedCreateWithoutActivityInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutActivityInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutActivityInput, ElectedMemberUncheckedUpdateWithoutActivityInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutActivityInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutActivityInput>
  }

  export type ElectedMemberCreateWithoutProvinceInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutProvinceInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutProvinceInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput>
  }

  export type ElectedMemberCreateManyProvinceInputEnvelope = {
    data: ElectedMemberCreateManyProvinceInput | ElectedMemberCreateManyProvinceInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutProvinceInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutProvinceInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutProvinceInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput>
  }

  export type UserCreateManyProvinceInputEnvelope = {
    data: UserCreateManyProvinceInput | UserCreateManyProvinceInput[]
    skipDuplicates?: boolean
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutProvinceInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutProvinceInput, ElectedMemberUncheckedUpdateWithoutProvinceInput>
    create: XOR<ElectedMemberCreateWithoutProvinceInput, ElectedMemberUncheckedCreateWithoutProvinceInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutProvinceInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutProvinceInput, ElectedMemberUncheckedUpdateWithoutProvinceInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutProvinceInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutProvinceInput>
  }

  export type UserUpsertWithWhereUniqueWithoutProvinceInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutProvinceInput, UserUncheckedUpdateWithoutProvinceInput>
    create: XOR<UserCreateWithoutProvinceInput, UserUncheckedCreateWithoutProvinceInput>
  }

  export type UserUpdateWithWhereUniqueWithoutProvinceInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutProvinceInput, UserUncheckedUpdateWithoutProvinceInput>
  }

  export type UserUpdateManyWithWhereWithoutProvinceInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutProvinceInput>
  }

  export type EditionCreateWithoutCategoryInput = {
    id?: string
    title: string
    document: string
    image?: string | null
  }

  export type EditionUncheckedCreateWithoutCategoryInput = {
    id?: string
    title: string
    document: string
    image?: string | null
  }

  export type EditionCreateOrConnectWithoutCategoryInput = {
    where: EditionWhereUniqueInput
    create: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput>
  }

  export type EditionCreateManyCategoryInputEnvelope = {
    data: EditionCreateManyCategoryInput | EditionCreateManyCategoryInput[]
    skipDuplicates?: boolean
  }

  export type EditionUpsertWithWhereUniqueWithoutCategoryInput = {
    where: EditionWhereUniqueInput
    update: XOR<EditionUpdateWithoutCategoryInput, EditionUncheckedUpdateWithoutCategoryInput>
    create: XOR<EditionCreateWithoutCategoryInput, EditionUncheckedCreateWithoutCategoryInput>
  }

  export type EditionUpdateWithWhereUniqueWithoutCategoryInput = {
    where: EditionWhereUniqueInput
    data: XOR<EditionUpdateWithoutCategoryInput, EditionUncheckedUpdateWithoutCategoryInput>
  }

  export type EditionUpdateManyWithWhereWithoutCategoryInput = {
    where: EditionScalarWhereInput
    data: XOR<EditionUpdateManyMutationInput, EditionUncheckedUpdateManyWithoutCategoryInput>
  }

  export type EditionScalarWhereInput = {
    AND?: EditionScalarWhereInput | EditionScalarWhereInput[]
    OR?: EditionScalarWhereInput[]
    NOT?: EditionScalarWhereInput | EditionScalarWhereInput[]
    id?: StringFilter<"Edition"> | string
    title?: StringFilter<"Edition"> | string
    categoryId?: StringFilter<"Edition"> | string
    document?: StringFilter<"Edition"> | string
    image?: StringNullableFilter<"Edition"> | string | null
  }

  export type ElectedMemberCreateWithoutMandateInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    college: CollegeCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutMandateInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutMandateInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput>
  }

  export type ElectedMemberCreateManyMandateInputEnvelope = {
    data: ElectedMemberCreateManyMandateInput | ElectedMemberCreateManyMandateInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutMandateInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMandateInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMandateInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput>
  }

  export type UserCreateManyMandateInputEnvelope = {
    data: UserCreateManyMandateInput | UserCreateManyMandateInput[]
    skipDuplicates?: boolean
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutMandateInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutMandateInput, ElectedMemberUncheckedUpdateWithoutMandateInput>
    create: XOR<ElectedMemberCreateWithoutMandateInput, ElectedMemberUncheckedCreateWithoutMandateInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutMandateInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutMandateInput, ElectedMemberUncheckedUpdateWithoutMandateInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutMandateInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutMandateInput>
  }

  export type UserUpsertWithWhereUniqueWithoutMandateInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutMandateInput, UserUncheckedUpdateWithoutMandateInput>
    create: XOR<UserCreateWithoutMandateInput, UserUncheckedCreateWithoutMandateInput>
  }

  export type UserUpdateWithWhereUniqueWithoutMandateInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutMandateInput, UserUncheckedUpdateWithoutMandateInput>
  }

  export type UserUpdateManyWithWhereWithoutMandateInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutMandateInput>
  }

  export type ElectedMemberCreateWithoutCollegeInput = {
    id?: string
    image?: string | null
    fullName: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
    position: PositionCreateNestedOneWithoutElectedMembersInput
    activityFamily: ActivityFamilyCreateNestedOneWithoutElectedMembersInput
    activity: ActivityCreateNestedOneWithoutElectedMembersInput
    province: ProvinceCreateNestedOneWithoutElectedMembersInput
    mandate: MandateCreateNestedOneWithoutElectedMembersInput
  }

  export type ElectedMemberUncheckedCreateWithoutCollegeInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberCreateOrConnectWithoutCollegeInput = {
    where: ElectedMemberWhereUniqueInput
    create: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput>
  }

  export type ElectedMemberCreateManyCollegeInputEnvelope = {
    data: ElectedMemberCreateManyCollegeInput | ElectedMemberCreateManyCollegeInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutCollegeInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCollegeInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCollegeInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput>
  }

  export type UserCreateManyCollegeInputEnvelope = {
    data: UserCreateManyCollegeInput | UserCreateManyCollegeInput[]
    skipDuplicates?: boolean
  }

  export type ElectedMemberUpsertWithWhereUniqueWithoutCollegeInput = {
    where: ElectedMemberWhereUniqueInput
    update: XOR<ElectedMemberUpdateWithoutCollegeInput, ElectedMemberUncheckedUpdateWithoutCollegeInput>
    create: XOR<ElectedMemberCreateWithoutCollegeInput, ElectedMemberUncheckedCreateWithoutCollegeInput>
  }

  export type ElectedMemberUpdateWithWhereUniqueWithoutCollegeInput = {
    where: ElectedMemberWhereUniqueInput
    data: XOR<ElectedMemberUpdateWithoutCollegeInput, ElectedMemberUncheckedUpdateWithoutCollegeInput>
  }

  export type ElectedMemberUpdateManyWithWhereWithoutCollegeInput = {
    where: ElectedMemberScalarWhereInput
    data: XOR<ElectedMemberUpdateManyMutationInput, ElectedMemberUncheckedUpdateManyWithoutCollegeInput>
  }

  export type UserUpsertWithWhereUniqueWithoutCollegeInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutCollegeInput, UserUncheckedUpdateWithoutCollegeInput>
    create: XOR<UserCreateWithoutCollegeInput, UserUncheckedCreateWithoutCollegeInput>
  }

  export type UserUpdateWithWhereUniqueWithoutCollegeInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutCollegeInput, UserUncheckedUpdateWithoutCollegeInput>
  }

  export type UserUpdateManyWithWhereWithoutCollegeInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutCollegeInput>
  }

  export type PositionCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    users?: UserCreateNestedManyWithoutPositionInput
    companies?: CompanyCreateNestedManyWithoutContactPositionInput
  }

  export type PositionUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    users?: UserUncheckedCreateNestedManyWithoutPositionInput
    companies?: CompanyUncheckedCreateNestedManyWithoutContactPositionInput
  }

  export type PositionCreateOrConnectWithoutElectedMembersInput = {
    where: PositionWhereUniqueInput
    create: XOR<PositionCreateWithoutElectedMembersInput, PositionUncheckedCreateWithoutElectedMembersInput>
  }

  export type ActivityFamilyCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    activities?: ActivityCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    activities?: ActivityUncheckedCreateNestedManyWithoutActivityFamilyInput
  }

  export type ActivityFamilyCreateOrConnectWithoutElectedMembersInput = {
    where: ActivityFamilyWhereUniqueInput
    create: XOR<ActivityFamilyCreateWithoutElectedMembersInput, ActivityFamilyUncheckedCreateWithoutElectedMembersInput>
  }

  export type ActivityCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    activityFamily: ActivityFamilyCreateNestedOneWithoutActivitiesInput
  }

  export type ActivityUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    activityFamilyId: string
  }

  export type ActivityCreateOrConnectWithoutElectedMembersInput = {
    where: ActivityWhereUniqueInput
    create: XOR<ActivityCreateWithoutElectedMembersInput, ActivityUncheckedCreateWithoutElectedMembersInput>
  }

  export type CollegeCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserCreateNestedManyWithoutCollegeInput
  }

  export type CollegeUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserUncheckedCreateNestedManyWithoutCollegeInput
  }

  export type CollegeCreateOrConnectWithoutElectedMembersInput = {
    where: CollegeWhereUniqueInput
    create: XOR<CollegeCreateWithoutElectedMembersInput, CollegeUncheckedCreateWithoutElectedMembersInput>
  }

  export type ProvinceCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserUncheckedCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceCreateOrConnectWithoutElectedMembersInput = {
    where: ProvinceWhereUniqueInput
    create: XOR<ProvinceCreateWithoutElectedMembersInput, ProvinceUncheckedCreateWithoutElectedMembersInput>
  }

  export type MandateCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserCreateNestedManyWithoutMandateInput
  }

  export type MandateUncheckedCreateWithoutElectedMembersInput = {
    id?: string
    name: string
    user?: UserUncheckedCreateNestedManyWithoutMandateInput
  }

  export type MandateCreateOrConnectWithoutElectedMembersInput = {
    where: MandateWhereUniqueInput
    create: XOR<MandateCreateWithoutElectedMembersInput, MandateUncheckedCreateWithoutElectedMembersInput>
  }

  export type PositionUpsertWithoutElectedMembersInput = {
    update: XOR<PositionUpdateWithoutElectedMembersInput, PositionUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<PositionCreateWithoutElectedMembersInput, PositionUncheckedCreateWithoutElectedMembersInput>
    where?: PositionWhereInput
  }

  export type PositionUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: PositionWhereInput
    data: XOR<PositionUpdateWithoutElectedMembersInput, PositionUncheckedUpdateWithoutElectedMembersInput>
  }

  export type PositionUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUpdateManyWithoutPositionNestedInput
    companies?: CompanyUpdateManyWithoutContactPositionNestedInput
  }

  export type PositionUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUncheckedUpdateManyWithoutPositionNestedInput
    companies?: CompanyUncheckedUpdateManyWithoutContactPositionNestedInput
  }

  export type ActivityFamilyUpsertWithoutElectedMembersInput = {
    update: XOR<ActivityFamilyUpdateWithoutElectedMembersInput, ActivityFamilyUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<ActivityFamilyCreateWithoutElectedMembersInput, ActivityFamilyUncheckedCreateWithoutElectedMembersInput>
    where?: ActivityFamilyWhereInput
  }

  export type ActivityFamilyUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: ActivityFamilyWhereInput
    data: XOR<ActivityFamilyUpdateWithoutElectedMembersInput, ActivityFamilyUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ActivityFamilyUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: ActivityUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ActivityFamilyUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: ActivityUncheckedUpdateManyWithoutActivityFamilyNestedInput
  }

  export type ActivityUpsertWithoutElectedMembersInput = {
    update: XOR<ActivityUpdateWithoutElectedMembersInput, ActivityUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<ActivityCreateWithoutElectedMembersInput, ActivityUncheckedCreateWithoutElectedMembersInput>
    where?: ActivityWhereInput
  }

  export type ActivityUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: ActivityWhereInput
    data: XOR<ActivityUpdateWithoutElectedMembersInput, ActivityUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ActivityUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type ActivityUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
  }

  export type CollegeUpsertWithoutElectedMembersInput = {
    update: XOR<CollegeUpdateWithoutElectedMembersInput, CollegeUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<CollegeCreateWithoutElectedMembersInput, CollegeUncheckedCreateWithoutElectedMembersInput>
    where?: CollegeWhereInput
  }

  export type CollegeUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: CollegeWhereInput
    data: XOR<CollegeUpdateWithoutElectedMembersInput, CollegeUncheckedUpdateWithoutElectedMembersInput>
  }

  export type CollegeUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateManyWithoutCollegeNestedInput
  }

  export type CollegeUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUncheckedUpdateManyWithoutCollegeNestedInput
  }

  export type ProvinceUpsertWithoutElectedMembersInput = {
    update: XOR<ProvinceUpdateWithoutElectedMembersInput, ProvinceUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<ProvinceCreateWithoutElectedMembersInput, ProvinceUncheckedCreateWithoutElectedMembersInput>
    where?: ProvinceWhereInput
  }

  export type ProvinceUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: ProvinceWhereInput
    data: XOR<ProvinceUpdateWithoutElectedMembersInput, ProvinceUncheckedUpdateWithoutElectedMembersInput>
  }

  export type ProvinceUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateManyWithoutProvinceNestedInput
  }

  export type ProvinceUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUncheckedUpdateManyWithoutProvinceNestedInput
  }

  export type MandateUpsertWithoutElectedMembersInput = {
    update: XOR<MandateUpdateWithoutElectedMembersInput, MandateUncheckedUpdateWithoutElectedMembersInput>
    create: XOR<MandateCreateWithoutElectedMembersInput, MandateUncheckedCreateWithoutElectedMembersInput>
    where?: MandateWhereInput
  }

  export type MandateUpdateToOneWithWhereWithoutElectedMembersInput = {
    where?: MandateWhereInput
    data: XOR<MandateUpdateWithoutElectedMembersInput, MandateUncheckedUpdateWithoutElectedMembersInput>
  }

  export type MandateUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateManyWithoutMandateNestedInput
  }

  export type MandateUncheckedUpdateWithoutElectedMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUncheckedUpdateManyWithoutMandateNestedInput
  }

  export type CityCreateWithoutUsersInput = {
    id?: string
    name: string
    companies?: CompanyCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    companies?: CompanyUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutUsersInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutUsersInput, CityUncheckedCreateWithoutUsersInput>
  }

  export type PositionCreateWithoutUsersInput = {
    id?: string
    name: string
    companies?: CompanyCreateNestedManyWithoutContactPositionInput
    electedMembers?: ElectedMemberCreateNestedManyWithoutPositionInput
  }

  export type PositionUncheckedCreateWithoutUsersInput = {
    id?: string
    name: string
    companies?: CompanyUncheckedCreateNestedManyWithoutContactPositionInput
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutPositionInput
  }

  export type PositionCreateOrConnectWithoutUsersInput = {
    where: PositionWhereUniqueInput
    create: XOR<PositionCreateWithoutUsersInput, PositionUncheckedCreateWithoutUsersInput>
  }

  export type CompanyCreateWithoutUsersInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutCompaniesInput
    contactPosition?: PositionCreateNestedOneWithoutCompaniesInput
    turnover?: TurnoverCreateNestedOneWithoutCompaniesInput
    nEmployees?: NEmployeesCreateNestedOneWithoutCompaniesInput
  }

  export type CompanyUncheckedCreateWithoutUsersInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type CompanyCreateOrConnectWithoutUsersInput = {
    where: CompanyWhereUniqueInput
    create: XOR<CompanyCreateWithoutUsersInput, CompanyUncheckedCreateWithoutUsersInput>
  }

  export type CollegeCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutCollegeInput
  }

  export type CollegeUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutCollegeInput
  }

  export type CollegeCreateOrConnectWithoutUserInput = {
    where: CollegeWhereUniqueInput
    create: XOR<CollegeCreateWithoutUserInput, CollegeUncheckedCreateWithoutUserInput>
  }

  export type ProvinceCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutProvinceInput
  }

  export type ProvinceCreateOrConnectWithoutUserInput = {
    where: ProvinceWhereUniqueInput
    create: XOR<ProvinceCreateWithoutUserInput, ProvinceUncheckedCreateWithoutUserInput>
  }

  export type MandateCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberCreateNestedManyWithoutMandateInput
  }

  export type MandateUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutMandateInput
  }

  export type MandateCreateOrConnectWithoutUserInput = {
    where: MandateWhereUniqueInput
    create: XOR<MandateCreateWithoutUserInput, MandateUncheckedCreateWithoutUserInput>
  }

  export type ConnectionCreateWithoutSenderInput = {
    id?: string
    accepted?: boolean
    createdAt?: Date | string
    receiver: UserCreateNestedOneWithoutConnectionsReceivedInput
  }

  export type ConnectionUncheckedCreateWithoutSenderInput = {
    id?: string
    receiverId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type ConnectionCreateOrConnectWithoutSenderInput = {
    where: ConnectionWhereUniqueInput
    create: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput>
  }

  export type ConnectionCreateManySenderInputEnvelope = {
    data: ConnectionCreateManySenderInput | ConnectionCreateManySenderInput[]
    skipDuplicates?: boolean
  }

  export type ConnectionCreateWithoutReceiverInput = {
    id?: string
    accepted?: boolean
    createdAt?: Date | string
    sender: UserCreateNestedOneWithoutConnectionsSentInput
  }

  export type ConnectionUncheckedCreateWithoutReceiverInput = {
    id?: string
    senderId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type ConnectionCreateOrConnectWithoutReceiverInput = {
    where: ConnectionWhereUniqueInput
    create: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput>
  }

  export type ConnectionCreateManyReceiverInputEnvelope = {
    data: ConnectionCreateManyReceiverInput | ConnectionCreateManyReceiverInput[]
    skipDuplicates?: boolean
  }

  export type MessageCreateWithoutSenderInput = {
    id?: string
    message: string
    read?: boolean
    createdAt?: Date | string
    receiver: UserCreateNestedOneWithoutMessagesReceivedInput
  }

  export type MessageUncheckedCreateWithoutSenderInput = {
    id?: string
    receiverId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type MessageCreateOrConnectWithoutSenderInput = {
    where: MessageWhereUniqueInput
    create: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput>
  }

  export type MessageCreateManySenderInputEnvelope = {
    data: MessageCreateManySenderInput | MessageCreateManySenderInput[]
    skipDuplicates?: boolean
  }

  export type MessageCreateWithoutReceiverInput = {
    id?: string
    message: string
    read?: boolean
    createdAt?: Date | string
    sender: UserCreateNestedOneWithoutMessagesSentInput
  }

  export type MessageUncheckedCreateWithoutReceiverInput = {
    id?: string
    senderId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type MessageCreateOrConnectWithoutReceiverInput = {
    where: MessageWhereUniqueInput
    create: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput>
  }

  export type MessageCreateManyReceiverInputEnvelope = {
    data: MessageCreateManyReceiverInput | MessageCreateManyReceiverInput[]
    skipDuplicates?: boolean
  }

  export type OpportunityCreateWithoutCreatorInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    likes?: OpportunityLikeCreateNestedManyWithoutOpportunityInput
    comments?: OpportunityCommentCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityUncheckedCreateWithoutCreatorInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    likes?: OpportunityLikeUncheckedCreateNestedManyWithoutOpportunityInput
    comments?: OpportunityCommentUncheckedCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityCreateOrConnectWithoutCreatorInput = {
    where: OpportunityWhereUniqueInput
    create: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput>
  }

  export type OpportunityCreateManyCreatorInputEnvelope = {
    data: OpportunityCreateManyCreatorInput | OpportunityCreateManyCreatorInput[]
    skipDuplicates?: boolean
  }

  export type OpportunityLikeCreateWithoutUserInput = {
    id?: string
    opportunity: OpportunityCreateNestedOneWithoutLikesInput
  }

  export type OpportunityLikeUncheckedCreateWithoutUserInput = {
    id?: string
    opportunityId: string
  }

  export type OpportunityLikeCreateOrConnectWithoutUserInput = {
    where: OpportunityLikeWhereUniqueInput
    create: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput>
  }

  export type OpportunityLikeCreateManyUserInputEnvelope = {
    data: OpportunityLikeCreateManyUserInput | OpportunityLikeCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type OpportunityCommentCreateWithoutUserInput = {
    id?: string
    content: string
    createdAt?: Date | string
    opportunity: OpportunityCreateNestedOneWithoutCommentsInput
  }

  export type OpportunityCommentUncheckedCreateWithoutUserInput = {
    id?: string
    content: string
    opportunityId: string
    createdAt?: Date | string
  }

  export type OpportunityCommentCreateOrConnectWithoutUserInput = {
    where: OpportunityCommentWhereUniqueInput
    create: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput>
  }

  export type OpportunityCommentCreateManyUserInputEnvelope = {
    data: OpportunityCommentCreateManyUserInput | OpportunityCommentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type EventLikeCreateWithoutUserInput = {
    id?: string
    event: EventCreateNestedOneWithoutLikesInput
  }

  export type EventLikeUncheckedCreateWithoutUserInput = {
    id?: string
    eventId: string
  }

  export type EventLikeCreateOrConnectWithoutUserInput = {
    where: EventLikeWhereUniqueInput
    create: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput>
  }

  export type EventLikeCreateManyUserInputEnvelope = {
    data: EventLikeCreateManyUserInput | EventLikeCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type EventCommentCreateWithoutUserInput = {
    id?: string
    content: string
    createdAt?: Date | string
    event: EventCreateNestedOneWithoutCommentsInput
  }

  export type EventCommentUncheckedCreateWithoutUserInput = {
    id?: string
    content: string
    eventId: string
    createdAt?: Date | string
  }

  export type EventCommentCreateOrConnectWithoutUserInput = {
    where: EventCommentWhereUniqueInput
    create: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput>
  }

  export type EventCommentCreateManyUserInputEnvelope = {
    data: EventCommentCreateManyUserInput | EventCommentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentLikeCreateWithoutUserInput = {
    id?: string
    appointment: AppointmentCreateNestedOneWithoutLikesInput
  }

  export type AppointmentLikeUncheckedCreateWithoutUserInput = {
    id?: string
    appointmentId: string
  }

  export type AppointmentLikeCreateOrConnectWithoutUserInput = {
    where: AppointmentLikeWhereUniqueInput
    create: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput>
  }

  export type AppointmentLikeCreateManyUserInputEnvelope = {
    data: AppointmentLikeCreateManyUserInput | AppointmentLikeCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentCommentCreateWithoutUserInput = {
    id?: string
    content: string
    createdAt?: Date | string
    appointment: AppointmentCreateNestedOneWithoutCommentsInput
  }

  export type AppointmentCommentUncheckedCreateWithoutUserInput = {
    id?: string
    content: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentCommentCreateOrConnectWithoutUserInput = {
    where: AppointmentCommentWhereUniqueInput
    create: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput>
  }

  export type AppointmentCommentCreateManyUserInputEnvelope = {
    data: AppointmentCommentCreateManyUserInput | AppointmentCommentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type NotificationCreateWithoutUserInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
  }

  export type NotificationUncheckedCreateWithoutUserInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
  }

  export type NotificationCreateOrConnectWithoutUserInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput>
  }

  export type NotificationCreateManyUserInputEnvelope = {
    data: NotificationCreateManyUserInput | NotificationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentRegistrationCreateWithoutUserInput = {
    id?: string
    createdAt?: Date | string
    appointment: AppointmentCreateNestedOneWithoutRegistrationsInput
  }

  export type AppointmentRegistrationUncheckedCreateWithoutUserInput = {
    id?: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type AppointmentRegistrationCreateOrConnectWithoutUserInput = {
    where: AppointmentRegistrationWhereUniqueInput
    create: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput>
  }

  export type AppointmentRegistrationCreateManyUserInputEnvelope = {
    data: AppointmentRegistrationCreateManyUserInput | AppointmentRegistrationCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type CityUpsertWithoutUsersInput = {
    update: XOR<CityUpdateWithoutUsersInput, CityUncheckedUpdateWithoutUsersInput>
    create: XOR<CityCreateWithoutUsersInput, CityUncheckedCreateWithoutUsersInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutUsersInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutUsersInput, CityUncheckedUpdateWithoutUsersInput>
  }

  export type CityUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUncheckedUpdateManyWithoutCityNestedInput
  }

  export type PositionUpsertWithoutUsersInput = {
    update: XOR<PositionUpdateWithoutUsersInput, PositionUncheckedUpdateWithoutUsersInput>
    create: XOR<PositionCreateWithoutUsersInput, PositionUncheckedCreateWithoutUsersInput>
    where?: PositionWhereInput
  }

  export type PositionUpdateToOneWithWhereWithoutUsersInput = {
    where?: PositionWhereInput
    data: XOR<PositionUpdateWithoutUsersInput, PositionUncheckedUpdateWithoutUsersInput>
  }

  export type PositionUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUpdateManyWithoutContactPositionNestedInput
    electedMembers?: ElectedMemberUpdateManyWithoutPositionNestedInput
  }

  export type PositionUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    companies?: CompanyUncheckedUpdateManyWithoutContactPositionNestedInput
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutPositionNestedInput
  }

  export type CompanyUpsertWithoutUsersInput = {
    update: XOR<CompanyUpdateWithoutUsersInput, CompanyUncheckedUpdateWithoutUsersInput>
    create: XOR<CompanyCreateWithoutUsersInput, CompanyUncheckedCreateWithoutUsersInput>
    where?: CompanyWhereInput
  }

  export type CompanyUpdateToOneWithWhereWithoutUsersInput = {
    where?: CompanyWhereInput
    data: XOR<CompanyUpdateWithoutUsersInput, CompanyUncheckedUpdateWithoutUsersInput>
  }

  export type CompanyUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCompaniesNestedInput
    contactPosition?: PositionUpdateOneWithoutCompaniesNestedInput
    turnover?: TurnoverUpdateOneWithoutCompaniesNestedInput
    nEmployees?: NEmployeesUpdateOneWithoutCompaniesNestedInput
  }

  export type CompanyUncheckedUpdateWithoutUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CollegeUpsertWithoutUserInput = {
    update: XOR<CollegeUpdateWithoutUserInput, CollegeUncheckedUpdateWithoutUserInput>
    create: XOR<CollegeCreateWithoutUserInput, CollegeUncheckedCreateWithoutUserInput>
    where?: CollegeWhereInput
  }

  export type CollegeUpdateToOneWithWhereWithoutUserInput = {
    where?: CollegeWhereInput
    data: XOR<CollegeUpdateWithoutUserInput, CollegeUncheckedUpdateWithoutUserInput>
  }

  export type CollegeUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutCollegeNestedInput
  }

  export type CollegeUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutCollegeNestedInput
  }

  export type ProvinceUpsertWithoutUserInput = {
    update: XOR<ProvinceUpdateWithoutUserInput, ProvinceUncheckedUpdateWithoutUserInput>
    create: XOR<ProvinceCreateWithoutUserInput, ProvinceUncheckedCreateWithoutUserInput>
    where?: ProvinceWhereInput
  }

  export type ProvinceUpdateToOneWithWhereWithoutUserInput = {
    where?: ProvinceWhereInput
    data: XOR<ProvinceUpdateWithoutUserInput, ProvinceUncheckedUpdateWithoutUserInput>
  }

  export type ProvinceUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutProvinceNestedInput
  }

  export type ProvinceUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutProvinceNestedInput
  }

  export type MandateUpsertWithoutUserInput = {
    update: XOR<MandateUpdateWithoutUserInput, MandateUncheckedUpdateWithoutUserInput>
    create: XOR<MandateCreateWithoutUserInput, MandateUncheckedCreateWithoutUserInput>
    where?: MandateWhereInput
  }

  export type MandateUpdateToOneWithWhereWithoutUserInput = {
    where?: MandateWhereInput
    data: XOR<MandateUpdateWithoutUserInput, MandateUncheckedUpdateWithoutUserInput>
  }

  export type MandateUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutMandateNestedInput
  }

  export type MandateUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutMandateNestedInput
  }

  export type ConnectionUpsertWithWhereUniqueWithoutSenderInput = {
    where: ConnectionWhereUniqueInput
    update: XOR<ConnectionUpdateWithoutSenderInput, ConnectionUncheckedUpdateWithoutSenderInput>
    create: XOR<ConnectionCreateWithoutSenderInput, ConnectionUncheckedCreateWithoutSenderInput>
  }

  export type ConnectionUpdateWithWhereUniqueWithoutSenderInput = {
    where: ConnectionWhereUniqueInput
    data: XOR<ConnectionUpdateWithoutSenderInput, ConnectionUncheckedUpdateWithoutSenderInput>
  }

  export type ConnectionUpdateManyWithWhereWithoutSenderInput = {
    where: ConnectionScalarWhereInput
    data: XOR<ConnectionUpdateManyMutationInput, ConnectionUncheckedUpdateManyWithoutSenderInput>
  }

  export type ConnectionScalarWhereInput = {
    AND?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
    OR?: ConnectionScalarWhereInput[]
    NOT?: ConnectionScalarWhereInput | ConnectionScalarWhereInput[]
    id?: StringFilter<"Connection"> | string
    senderId?: StringFilter<"Connection"> | string
    receiverId?: StringFilter<"Connection"> | string
    accepted?: BoolFilter<"Connection"> | boolean
    createdAt?: DateTimeFilter<"Connection"> | Date | string
  }

  export type ConnectionUpsertWithWhereUniqueWithoutReceiverInput = {
    where: ConnectionWhereUniqueInput
    update: XOR<ConnectionUpdateWithoutReceiverInput, ConnectionUncheckedUpdateWithoutReceiverInput>
    create: XOR<ConnectionCreateWithoutReceiverInput, ConnectionUncheckedCreateWithoutReceiverInput>
  }

  export type ConnectionUpdateWithWhereUniqueWithoutReceiverInput = {
    where: ConnectionWhereUniqueInput
    data: XOR<ConnectionUpdateWithoutReceiverInput, ConnectionUncheckedUpdateWithoutReceiverInput>
  }

  export type ConnectionUpdateManyWithWhereWithoutReceiverInput = {
    where: ConnectionScalarWhereInput
    data: XOR<ConnectionUpdateManyMutationInput, ConnectionUncheckedUpdateManyWithoutReceiverInput>
  }

  export type MessageUpsertWithWhereUniqueWithoutSenderInput = {
    where: MessageWhereUniqueInput
    update: XOR<MessageUpdateWithoutSenderInput, MessageUncheckedUpdateWithoutSenderInput>
    create: XOR<MessageCreateWithoutSenderInput, MessageUncheckedCreateWithoutSenderInput>
  }

  export type MessageUpdateWithWhereUniqueWithoutSenderInput = {
    where: MessageWhereUniqueInput
    data: XOR<MessageUpdateWithoutSenderInput, MessageUncheckedUpdateWithoutSenderInput>
  }

  export type MessageUpdateManyWithWhereWithoutSenderInput = {
    where: MessageScalarWhereInput
    data: XOR<MessageUpdateManyMutationInput, MessageUncheckedUpdateManyWithoutSenderInput>
  }

  export type MessageScalarWhereInput = {
    AND?: MessageScalarWhereInput | MessageScalarWhereInput[]
    OR?: MessageScalarWhereInput[]
    NOT?: MessageScalarWhereInput | MessageScalarWhereInput[]
    id?: StringFilter<"Message"> | string
    senderId?: StringFilter<"Message"> | string
    receiverId?: StringFilter<"Message"> | string
    message?: StringFilter<"Message"> | string
    read?: BoolFilter<"Message"> | boolean
    createdAt?: DateTimeFilter<"Message"> | Date | string
  }

  export type MessageUpsertWithWhereUniqueWithoutReceiverInput = {
    where: MessageWhereUniqueInput
    update: XOR<MessageUpdateWithoutReceiverInput, MessageUncheckedUpdateWithoutReceiverInput>
    create: XOR<MessageCreateWithoutReceiverInput, MessageUncheckedCreateWithoutReceiverInput>
  }

  export type MessageUpdateWithWhereUniqueWithoutReceiverInput = {
    where: MessageWhereUniqueInput
    data: XOR<MessageUpdateWithoutReceiverInput, MessageUncheckedUpdateWithoutReceiverInput>
  }

  export type MessageUpdateManyWithWhereWithoutReceiverInput = {
    where: MessageScalarWhereInput
    data: XOR<MessageUpdateManyMutationInput, MessageUncheckedUpdateManyWithoutReceiverInput>
  }

  export type OpportunityUpsertWithWhereUniqueWithoutCreatorInput = {
    where: OpportunityWhereUniqueInput
    update: XOR<OpportunityUpdateWithoutCreatorInput, OpportunityUncheckedUpdateWithoutCreatorInput>
    create: XOR<OpportunityCreateWithoutCreatorInput, OpportunityUncheckedCreateWithoutCreatorInput>
  }

  export type OpportunityUpdateWithWhereUniqueWithoutCreatorInput = {
    where: OpportunityWhereUniqueInput
    data: XOR<OpportunityUpdateWithoutCreatorInput, OpportunityUncheckedUpdateWithoutCreatorInput>
  }

  export type OpportunityUpdateManyWithWhereWithoutCreatorInput = {
    where: OpportunityScalarWhereInput
    data: XOR<OpportunityUpdateManyMutationInput, OpportunityUncheckedUpdateManyWithoutCreatorInput>
  }

  export type OpportunityScalarWhereInput = {
    AND?: OpportunityScalarWhereInput | OpportunityScalarWhereInput[]
    OR?: OpportunityScalarWhereInput[]
    NOT?: OpportunityScalarWhereInput | OpportunityScalarWhereInput[]
    id?: StringFilter<"Opportunity"> | string
    title?: StringFilter<"Opportunity"> | string
    description?: StringFilter<"Opportunity"> | string
    companyName?: StringFilter<"Opportunity"> | string
    activitiesFamilies?: StringNullableListFilter<"Opportunity">
    activities?: StringNullableListFilter<"Opportunity">
    country?: StringFilter<"Opportunity"> | string
    address?: StringFilter<"Opportunity"> | string
    requirements?: StringFilter<"Opportunity"> | string
    contactEmail?: StringFilter<"Opportunity"> | string
    contactPhoneNumber?: StringFilter<"Opportunity"> | string
    creatorId?: StringFilter<"Opportunity"> | string
    document?: StringNullableFilter<"Opportunity"> | string | null
    verified?: BoolFilter<"Opportunity"> | boolean
    active?: BoolFilter<"Opportunity"> | boolean
    validityDate?: DateTimeNullableFilter<"Opportunity"> | Date | string | null
    createdAt?: DateTimeFilter<"Opportunity"> | Date | string
  }

  export type OpportunityLikeUpsertWithWhereUniqueWithoutUserInput = {
    where: OpportunityLikeWhereUniqueInput
    update: XOR<OpportunityLikeUpdateWithoutUserInput, OpportunityLikeUncheckedUpdateWithoutUserInput>
    create: XOR<OpportunityLikeCreateWithoutUserInput, OpportunityLikeUncheckedCreateWithoutUserInput>
  }

  export type OpportunityLikeUpdateWithWhereUniqueWithoutUserInput = {
    where: OpportunityLikeWhereUniqueInput
    data: XOR<OpportunityLikeUpdateWithoutUserInput, OpportunityLikeUncheckedUpdateWithoutUserInput>
  }

  export type OpportunityLikeUpdateManyWithWhereWithoutUserInput = {
    where: OpportunityLikeScalarWhereInput
    data: XOR<OpportunityLikeUpdateManyMutationInput, OpportunityLikeUncheckedUpdateManyWithoutUserInput>
  }

  export type OpportunityLikeScalarWhereInput = {
    AND?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
    OR?: OpportunityLikeScalarWhereInput[]
    NOT?: OpportunityLikeScalarWhereInput | OpportunityLikeScalarWhereInput[]
    id?: StringFilter<"OpportunityLike"> | string
    userId?: StringFilter<"OpportunityLike"> | string
    opportunityId?: StringFilter<"OpportunityLike"> | string
  }

  export type OpportunityCommentUpsertWithWhereUniqueWithoutUserInput = {
    where: OpportunityCommentWhereUniqueInput
    update: XOR<OpportunityCommentUpdateWithoutUserInput, OpportunityCommentUncheckedUpdateWithoutUserInput>
    create: XOR<OpportunityCommentCreateWithoutUserInput, OpportunityCommentUncheckedCreateWithoutUserInput>
  }

  export type OpportunityCommentUpdateWithWhereUniqueWithoutUserInput = {
    where: OpportunityCommentWhereUniqueInput
    data: XOR<OpportunityCommentUpdateWithoutUserInput, OpportunityCommentUncheckedUpdateWithoutUserInput>
  }

  export type OpportunityCommentUpdateManyWithWhereWithoutUserInput = {
    where: OpportunityCommentScalarWhereInput
    data: XOR<OpportunityCommentUpdateManyMutationInput, OpportunityCommentUncheckedUpdateManyWithoutUserInput>
  }

  export type OpportunityCommentScalarWhereInput = {
    AND?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
    OR?: OpportunityCommentScalarWhereInput[]
    NOT?: OpportunityCommentScalarWhereInput | OpportunityCommentScalarWhereInput[]
    id?: StringFilter<"OpportunityComment"> | string
    content?: StringFilter<"OpportunityComment"> | string
    userId?: StringFilter<"OpportunityComment"> | string
    opportunityId?: StringFilter<"OpportunityComment"> | string
    createdAt?: DateTimeFilter<"OpportunityComment"> | Date | string
  }

  export type EventLikeUpsertWithWhereUniqueWithoutUserInput = {
    where: EventLikeWhereUniqueInput
    update: XOR<EventLikeUpdateWithoutUserInput, EventLikeUncheckedUpdateWithoutUserInput>
    create: XOR<EventLikeCreateWithoutUserInput, EventLikeUncheckedCreateWithoutUserInput>
  }

  export type EventLikeUpdateWithWhereUniqueWithoutUserInput = {
    where: EventLikeWhereUniqueInput
    data: XOR<EventLikeUpdateWithoutUserInput, EventLikeUncheckedUpdateWithoutUserInput>
  }

  export type EventLikeUpdateManyWithWhereWithoutUserInput = {
    where: EventLikeScalarWhereInput
    data: XOR<EventLikeUpdateManyMutationInput, EventLikeUncheckedUpdateManyWithoutUserInput>
  }

  export type EventLikeScalarWhereInput = {
    AND?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
    OR?: EventLikeScalarWhereInput[]
    NOT?: EventLikeScalarWhereInput | EventLikeScalarWhereInput[]
    id?: StringFilter<"EventLike"> | string
    userId?: StringFilter<"EventLike"> | string
    eventId?: StringFilter<"EventLike"> | string
  }

  export type EventCommentUpsertWithWhereUniqueWithoutUserInput = {
    where: EventCommentWhereUniqueInput
    update: XOR<EventCommentUpdateWithoutUserInput, EventCommentUncheckedUpdateWithoutUserInput>
    create: XOR<EventCommentCreateWithoutUserInput, EventCommentUncheckedCreateWithoutUserInput>
  }

  export type EventCommentUpdateWithWhereUniqueWithoutUserInput = {
    where: EventCommentWhereUniqueInput
    data: XOR<EventCommentUpdateWithoutUserInput, EventCommentUncheckedUpdateWithoutUserInput>
  }

  export type EventCommentUpdateManyWithWhereWithoutUserInput = {
    where: EventCommentScalarWhereInput
    data: XOR<EventCommentUpdateManyMutationInput, EventCommentUncheckedUpdateManyWithoutUserInput>
  }

  export type EventCommentScalarWhereInput = {
    AND?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
    OR?: EventCommentScalarWhereInput[]
    NOT?: EventCommentScalarWhereInput | EventCommentScalarWhereInput[]
    id?: StringFilter<"EventComment"> | string
    content?: StringFilter<"EventComment"> | string
    userId?: StringFilter<"EventComment"> | string
    eventId?: StringFilter<"EventComment"> | string
    createdAt?: DateTimeFilter<"EventComment"> | Date | string
  }

  export type AppointmentLikeUpsertWithWhereUniqueWithoutUserInput = {
    where: AppointmentLikeWhereUniqueInput
    update: XOR<AppointmentLikeUpdateWithoutUserInput, AppointmentLikeUncheckedUpdateWithoutUserInput>
    create: XOR<AppointmentLikeCreateWithoutUserInput, AppointmentLikeUncheckedCreateWithoutUserInput>
  }

  export type AppointmentLikeUpdateWithWhereUniqueWithoutUserInput = {
    where: AppointmentLikeWhereUniqueInput
    data: XOR<AppointmentLikeUpdateWithoutUserInput, AppointmentLikeUncheckedUpdateWithoutUserInput>
  }

  export type AppointmentLikeUpdateManyWithWhereWithoutUserInput = {
    where: AppointmentLikeScalarWhereInput
    data: XOR<AppointmentLikeUpdateManyMutationInput, AppointmentLikeUncheckedUpdateManyWithoutUserInput>
  }

  export type AppointmentLikeScalarWhereInput = {
    AND?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
    OR?: AppointmentLikeScalarWhereInput[]
    NOT?: AppointmentLikeScalarWhereInput | AppointmentLikeScalarWhereInput[]
    id?: StringFilter<"AppointmentLike"> | string
    userId?: StringFilter<"AppointmentLike"> | string
    appointmentId?: StringFilter<"AppointmentLike"> | string
  }

  export type AppointmentCommentUpsertWithWhereUniqueWithoutUserInput = {
    where: AppointmentCommentWhereUniqueInput
    update: XOR<AppointmentCommentUpdateWithoutUserInput, AppointmentCommentUncheckedUpdateWithoutUserInput>
    create: XOR<AppointmentCommentCreateWithoutUserInput, AppointmentCommentUncheckedCreateWithoutUserInput>
  }

  export type AppointmentCommentUpdateWithWhereUniqueWithoutUserInput = {
    where: AppointmentCommentWhereUniqueInput
    data: XOR<AppointmentCommentUpdateWithoutUserInput, AppointmentCommentUncheckedUpdateWithoutUserInput>
  }

  export type AppointmentCommentUpdateManyWithWhereWithoutUserInput = {
    where: AppointmentCommentScalarWhereInput
    data: XOR<AppointmentCommentUpdateManyMutationInput, AppointmentCommentUncheckedUpdateManyWithoutUserInput>
  }

  export type AppointmentCommentScalarWhereInput = {
    AND?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
    OR?: AppointmentCommentScalarWhereInput[]
    NOT?: AppointmentCommentScalarWhereInput | AppointmentCommentScalarWhereInput[]
    id?: StringFilter<"AppointmentComment"> | string
    content?: StringFilter<"AppointmentComment"> | string
    userId?: StringFilter<"AppointmentComment"> | string
    appointmentId?: StringFilter<"AppointmentComment"> | string
    createdAt?: DateTimeFilter<"AppointmentComment"> | Date | string
  }

  export type NotificationUpsertWithWhereUniqueWithoutUserInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutUserInput, NotificationUncheckedUpdateWithoutUserInput>
    create: XOR<NotificationCreateWithoutUserInput, NotificationUncheckedCreateWithoutUserInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutUserInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutUserInput, NotificationUncheckedUpdateWithoutUserInput>
  }

  export type NotificationUpdateManyWithWhereWithoutUserInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutUserInput>
  }

  export type NotificationScalarWhereInput = {
    AND?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    OR?: NotificationScalarWhereInput[]
    NOT?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    id?: StringFilter<"Notification"> | string
    title?: StringFilter<"Notification"> | string
    content?: StringFilter<"Notification"> | string
    source?: EnumSourceFilter<"Notification"> | $Enums.Source
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    isRead?: BoolFilter<"Notification"> | boolean
    userId?: StringFilter<"Notification"> | string
  }

  export type AppointmentRegistrationUpsertWithWhereUniqueWithoutUserInput = {
    where: AppointmentRegistrationWhereUniqueInput
    update: XOR<AppointmentRegistrationUpdateWithoutUserInput, AppointmentRegistrationUncheckedUpdateWithoutUserInput>
    create: XOR<AppointmentRegistrationCreateWithoutUserInput, AppointmentRegistrationUncheckedCreateWithoutUserInput>
  }

  export type AppointmentRegistrationUpdateWithWhereUniqueWithoutUserInput = {
    where: AppointmentRegistrationWhereUniqueInput
    data: XOR<AppointmentRegistrationUpdateWithoutUserInput, AppointmentRegistrationUncheckedUpdateWithoutUserInput>
  }

  export type AppointmentRegistrationUpdateManyWithWhereWithoutUserInput = {
    where: AppointmentRegistrationScalarWhereInput
    data: XOR<AppointmentRegistrationUpdateManyMutationInput, AppointmentRegistrationUncheckedUpdateManyWithoutUserInput>
  }

  export type AppointmentRegistrationScalarWhereInput = {
    AND?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
    OR?: AppointmentRegistrationScalarWhereInput[]
    NOT?: AppointmentRegistrationScalarWhereInput | AppointmentRegistrationScalarWhereInput[]
    id?: StringFilter<"AppointmentRegistration"> | string
    userId?: StringFilter<"AppointmentRegistration"> | string
    appointmentId?: StringFilter<"AppointmentRegistration"> | string
    createdAt?: DateTimeFilter<"AppointmentRegistration"> | Date | string
  }

  export type UserCreateWithoutNotificationsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutNotificationsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutNotificationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
  }

  export type UserUpsertWithoutNotificationsInput = {
    update: XOR<UserUpdateWithoutNotificationsInput, UserUncheckedUpdateWithoutNotificationsInput>
    create: XOR<UserCreateWithoutNotificationsInput, UserUncheckedCreateWithoutNotificationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutNotificationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutNotificationsInput, UserUncheckedUpdateWithoutNotificationsInput>
  }

  export type UserUpdateWithoutNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type CityCreateWithoutCompaniesInput = {
    id?: string
    name: string
    users?: UserCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutCompaniesInput = {
    id?: string
    name: string
    users?: UserUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutCompaniesInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutCompaniesInput, CityUncheckedCreateWithoutCompaniesInput>
  }

  export type PositionCreateWithoutCompaniesInput = {
    id?: string
    name: string
    users?: UserCreateNestedManyWithoutPositionInput
    electedMembers?: ElectedMemberCreateNestedManyWithoutPositionInput
  }

  export type PositionUncheckedCreateWithoutCompaniesInput = {
    id?: string
    name: string
    users?: UserUncheckedCreateNestedManyWithoutPositionInput
    electedMembers?: ElectedMemberUncheckedCreateNestedManyWithoutPositionInput
  }

  export type PositionCreateOrConnectWithoutCompaniesInput = {
    where: PositionWhereUniqueInput
    create: XOR<PositionCreateWithoutCompaniesInput, PositionUncheckedCreateWithoutCompaniesInput>
  }

  export type TurnoverCreateWithoutCompaniesInput = {
    id?: string
    name: string
  }

  export type TurnoverUncheckedCreateWithoutCompaniesInput = {
    id?: string
    name: string
  }

  export type TurnoverCreateOrConnectWithoutCompaniesInput = {
    where: TurnoverWhereUniqueInput
    create: XOR<TurnoverCreateWithoutCompaniesInput, TurnoverUncheckedCreateWithoutCompaniesInput>
  }

  export type NEmployeesCreateWithoutCompaniesInput = {
    id?: string
    name: string
  }

  export type NEmployeesUncheckedCreateWithoutCompaniesInput = {
    id?: string
    name: string
  }

  export type NEmployeesCreateOrConnectWithoutCompaniesInput = {
    where: NEmployeesWhereUniqueInput
    create: XOR<NEmployeesCreateWithoutCompaniesInput, NEmployeesUncheckedCreateWithoutCompaniesInput>
  }

  export type UserCreateWithoutCompanyInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutCompanyInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutCompanyInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput>
  }

  export type UserCreateManyCompanyInputEnvelope = {
    data: UserCreateManyCompanyInput | UserCreateManyCompanyInput[]
    skipDuplicates?: boolean
  }

  export type CityUpsertWithoutCompaniesInput = {
    update: XOR<CityUpdateWithoutCompaniesInput, CityUncheckedUpdateWithoutCompaniesInput>
    create: XOR<CityCreateWithoutCompaniesInput, CityUncheckedCreateWithoutCompaniesInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutCompaniesInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutCompaniesInput, CityUncheckedUpdateWithoutCompaniesInput>
  }

  export type CityUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUncheckedUpdateManyWithoutCityNestedInput
  }

  export type PositionUpsertWithoutCompaniesInput = {
    update: XOR<PositionUpdateWithoutCompaniesInput, PositionUncheckedUpdateWithoutCompaniesInput>
    create: XOR<PositionCreateWithoutCompaniesInput, PositionUncheckedCreateWithoutCompaniesInput>
    where?: PositionWhereInput
  }

  export type PositionUpdateToOneWithWhereWithoutCompaniesInput = {
    where?: PositionWhereInput
    data: XOR<PositionUpdateWithoutCompaniesInput, PositionUncheckedUpdateWithoutCompaniesInput>
  }

  export type PositionUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUpdateManyWithoutPositionNestedInput
    electedMembers?: ElectedMemberUpdateManyWithoutPositionNestedInput
  }

  export type PositionUncheckedUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    users?: UserUncheckedUpdateManyWithoutPositionNestedInput
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutPositionNestedInput
  }

  export type TurnoverUpsertWithoutCompaniesInput = {
    update: XOR<TurnoverUpdateWithoutCompaniesInput, TurnoverUncheckedUpdateWithoutCompaniesInput>
    create: XOR<TurnoverCreateWithoutCompaniesInput, TurnoverUncheckedCreateWithoutCompaniesInput>
    where?: TurnoverWhereInput
  }

  export type TurnoverUpdateToOneWithWhereWithoutCompaniesInput = {
    where?: TurnoverWhereInput
    data: XOR<TurnoverUpdateWithoutCompaniesInput, TurnoverUncheckedUpdateWithoutCompaniesInput>
  }

  export type TurnoverUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type TurnoverUncheckedUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type NEmployeesUpsertWithoutCompaniesInput = {
    update: XOR<NEmployeesUpdateWithoutCompaniesInput, NEmployeesUncheckedUpdateWithoutCompaniesInput>
    create: XOR<NEmployeesCreateWithoutCompaniesInput, NEmployeesUncheckedCreateWithoutCompaniesInput>
    where?: NEmployeesWhereInput
  }

  export type NEmployeesUpdateToOneWithWhereWithoutCompaniesInput = {
    where?: NEmployeesWhereInput
    data: XOR<NEmployeesUpdateWithoutCompaniesInput, NEmployeesUncheckedUpdateWithoutCompaniesInput>
  }

  export type NEmployeesUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type NEmployeesUncheckedUpdateWithoutCompaniesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpsertWithWhereUniqueWithoutCompanyInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutCompanyInput, UserUncheckedUpdateWithoutCompanyInput>
    create: XOR<UserCreateWithoutCompanyInput, UserUncheckedCreateWithoutCompanyInput>
  }

  export type UserUpdateWithWhereUniqueWithoutCompanyInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutCompanyInput, UserUncheckedUpdateWithoutCompanyInput>
  }

  export type UserUpdateManyWithWhereWithoutCompanyInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutCompanyInput>
  }

  export type UserCreateWithoutConnectionsSentInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutConnectionsSentInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutConnectionsSentInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutConnectionsSentInput, UserUncheckedCreateWithoutConnectionsSentInput>
  }

  export type UserCreateWithoutConnectionsReceivedInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutConnectionsReceivedInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutConnectionsReceivedInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutConnectionsReceivedInput, UserUncheckedCreateWithoutConnectionsReceivedInput>
  }

  export type UserUpsertWithoutConnectionsSentInput = {
    update: XOR<UserUpdateWithoutConnectionsSentInput, UserUncheckedUpdateWithoutConnectionsSentInput>
    create: XOR<UserCreateWithoutConnectionsSentInput, UserUncheckedCreateWithoutConnectionsSentInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutConnectionsSentInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutConnectionsSentInput, UserUncheckedUpdateWithoutConnectionsSentInput>
  }

  export type UserUpdateWithoutConnectionsSentInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutConnectionsSentInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUpsertWithoutConnectionsReceivedInput = {
    update: XOR<UserUpdateWithoutConnectionsReceivedInput, UserUncheckedUpdateWithoutConnectionsReceivedInput>
    create: XOR<UserCreateWithoutConnectionsReceivedInput, UserUncheckedCreateWithoutConnectionsReceivedInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutConnectionsReceivedInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutConnectionsReceivedInput, UserUncheckedUpdateWithoutConnectionsReceivedInput>
  }

  export type UserUpdateWithoutConnectionsReceivedInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutConnectionsReceivedInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutMessagesSentInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMessagesSentInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMessagesSentInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMessagesSentInput, UserUncheckedCreateWithoutMessagesSentInput>
  }

  export type UserCreateWithoutMessagesReceivedInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMessagesReceivedInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMessagesReceivedInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMessagesReceivedInput, UserUncheckedCreateWithoutMessagesReceivedInput>
  }

  export type UserUpsertWithoutMessagesSentInput = {
    update: XOR<UserUpdateWithoutMessagesSentInput, UserUncheckedUpdateWithoutMessagesSentInput>
    create: XOR<UserCreateWithoutMessagesSentInput, UserUncheckedCreateWithoutMessagesSentInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutMessagesSentInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutMessagesSentInput, UserUncheckedUpdateWithoutMessagesSentInput>
  }

  export type UserUpdateWithoutMessagesSentInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMessagesSentInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUpsertWithoutMessagesReceivedInput = {
    update: XOR<UserUpdateWithoutMessagesReceivedInput, UserUncheckedUpdateWithoutMessagesReceivedInput>
    create: XOR<UserCreateWithoutMessagesReceivedInput, UserUncheckedCreateWithoutMessagesReceivedInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutMessagesReceivedInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutMessagesReceivedInput, UserUncheckedUpdateWithoutMessagesReceivedInput>
  }

  export type UserUpdateWithoutMessagesReceivedInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMessagesReceivedInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutOpportunitiesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutOpportunitiesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutOpportunitiesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutOpportunitiesInput, UserUncheckedCreateWithoutOpportunitiesInput>
  }

  export type OpportunityLikeCreateWithoutOpportunityInput = {
    id?: string
    user: UserCreateNestedOneWithoutOpportunityLikesInput
  }

  export type OpportunityLikeUncheckedCreateWithoutOpportunityInput = {
    id?: string
    userId: string
  }

  export type OpportunityLikeCreateOrConnectWithoutOpportunityInput = {
    where: OpportunityLikeWhereUniqueInput
    create: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput>
  }

  export type OpportunityLikeCreateManyOpportunityInputEnvelope = {
    data: OpportunityLikeCreateManyOpportunityInput | OpportunityLikeCreateManyOpportunityInput[]
    skipDuplicates?: boolean
  }

  export type OpportunityCommentCreateWithoutOpportunityInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutOpportunityCommentsInput
  }

  export type OpportunityCommentUncheckedCreateWithoutOpportunityInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type OpportunityCommentCreateOrConnectWithoutOpportunityInput = {
    where: OpportunityCommentWhereUniqueInput
    create: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput>
  }

  export type OpportunityCommentCreateManyOpportunityInputEnvelope = {
    data: OpportunityCommentCreateManyOpportunityInput | OpportunityCommentCreateManyOpportunityInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutOpportunitiesInput = {
    update: XOR<UserUpdateWithoutOpportunitiesInput, UserUncheckedUpdateWithoutOpportunitiesInput>
    create: XOR<UserCreateWithoutOpportunitiesInput, UserUncheckedCreateWithoutOpportunitiesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutOpportunitiesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutOpportunitiesInput, UserUncheckedUpdateWithoutOpportunitiesInput>
  }

  export type UserUpdateWithoutOpportunitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutOpportunitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OpportunityLikeUpsertWithWhereUniqueWithoutOpportunityInput = {
    where: OpportunityLikeWhereUniqueInput
    update: XOR<OpportunityLikeUpdateWithoutOpportunityInput, OpportunityLikeUncheckedUpdateWithoutOpportunityInput>
    create: XOR<OpportunityLikeCreateWithoutOpportunityInput, OpportunityLikeUncheckedCreateWithoutOpportunityInput>
  }

  export type OpportunityLikeUpdateWithWhereUniqueWithoutOpportunityInput = {
    where: OpportunityLikeWhereUniqueInput
    data: XOR<OpportunityLikeUpdateWithoutOpportunityInput, OpportunityLikeUncheckedUpdateWithoutOpportunityInput>
  }

  export type OpportunityLikeUpdateManyWithWhereWithoutOpportunityInput = {
    where: OpportunityLikeScalarWhereInput
    data: XOR<OpportunityLikeUpdateManyMutationInput, OpportunityLikeUncheckedUpdateManyWithoutOpportunityInput>
  }

  export type OpportunityCommentUpsertWithWhereUniqueWithoutOpportunityInput = {
    where: OpportunityCommentWhereUniqueInput
    update: XOR<OpportunityCommentUpdateWithoutOpportunityInput, OpportunityCommentUncheckedUpdateWithoutOpportunityInput>
    create: XOR<OpportunityCommentCreateWithoutOpportunityInput, OpportunityCommentUncheckedCreateWithoutOpportunityInput>
  }

  export type OpportunityCommentUpdateWithWhereUniqueWithoutOpportunityInput = {
    where: OpportunityCommentWhereUniqueInput
    data: XOR<OpportunityCommentUpdateWithoutOpportunityInput, OpportunityCommentUncheckedUpdateWithoutOpportunityInput>
  }

  export type OpportunityCommentUpdateManyWithWhereWithoutOpportunityInput = {
    where: OpportunityCommentScalarWhereInput
    data: XOR<OpportunityCommentUpdateManyMutationInput, OpportunityCommentUncheckedUpdateManyWithoutOpportunityInput>
  }

  export type UserCreateWithoutOpportunityLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutOpportunityLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutOpportunityLikesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutOpportunityLikesInput, UserUncheckedCreateWithoutOpportunityLikesInput>
  }

  export type OpportunityCreateWithoutLikesInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    creator: UserCreateNestedOneWithoutOpportunitiesInput
    comments?: OpportunityCommentCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityUncheckedCreateWithoutLikesInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    creatorId: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    comments?: OpportunityCommentUncheckedCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityCreateOrConnectWithoutLikesInput = {
    where: OpportunityWhereUniqueInput
    create: XOR<OpportunityCreateWithoutLikesInput, OpportunityUncheckedCreateWithoutLikesInput>
  }

  export type UserUpsertWithoutOpportunityLikesInput = {
    update: XOR<UserUpdateWithoutOpportunityLikesInput, UserUncheckedUpdateWithoutOpportunityLikesInput>
    create: XOR<UserCreateWithoutOpportunityLikesInput, UserUncheckedCreateWithoutOpportunityLikesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutOpportunityLikesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutOpportunityLikesInput, UserUncheckedUpdateWithoutOpportunityLikesInput>
  }

  export type UserUpdateWithoutOpportunityLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutOpportunityLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OpportunityUpsertWithoutLikesInput = {
    update: XOR<OpportunityUpdateWithoutLikesInput, OpportunityUncheckedUpdateWithoutLikesInput>
    create: XOR<OpportunityCreateWithoutLikesInput, OpportunityUncheckedCreateWithoutLikesInput>
    where?: OpportunityWhereInput
  }

  export type OpportunityUpdateToOneWithWhereWithoutLikesInput = {
    where?: OpportunityWhereInput
    data: XOR<OpportunityUpdateWithoutLikesInput, OpportunityUncheckedUpdateWithoutLikesInput>
  }

  export type OpportunityUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    creator?: UserUpdateOneRequiredWithoutOpportunitiesNestedInput
    comments?: OpportunityCommentUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityUncheckedUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    creatorId?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    comments?: OpportunityCommentUncheckedUpdateManyWithoutOpportunityNestedInput
  }

  export type UserCreateWithoutOpportunityCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutOpportunityCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutOpportunityCommentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutOpportunityCommentsInput, UserUncheckedCreateWithoutOpportunityCommentsInput>
  }

  export type OpportunityCreateWithoutCommentsInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    creator: UserCreateNestedOneWithoutOpportunitiesInput
    likes?: OpportunityLikeCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityUncheckedCreateWithoutCommentsInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    creatorId: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
    likes?: OpportunityLikeUncheckedCreateNestedManyWithoutOpportunityInput
  }

  export type OpportunityCreateOrConnectWithoutCommentsInput = {
    where: OpportunityWhereUniqueInput
    create: XOR<OpportunityCreateWithoutCommentsInput, OpportunityUncheckedCreateWithoutCommentsInput>
  }

  export type UserUpsertWithoutOpportunityCommentsInput = {
    update: XOR<UserUpdateWithoutOpportunityCommentsInput, UserUncheckedUpdateWithoutOpportunityCommentsInput>
    create: XOR<UserCreateWithoutOpportunityCommentsInput, UserUncheckedCreateWithoutOpportunityCommentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutOpportunityCommentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutOpportunityCommentsInput, UserUncheckedUpdateWithoutOpportunityCommentsInput>
  }

  export type UserUpdateWithoutOpportunityCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutOpportunityCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OpportunityUpsertWithoutCommentsInput = {
    update: XOR<OpportunityUpdateWithoutCommentsInput, OpportunityUncheckedUpdateWithoutCommentsInput>
    create: XOR<OpportunityCreateWithoutCommentsInput, OpportunityUncheckedCreateWithoutCommentsInput>
    where?: OpportunityWhereInput
  }

  export type OpportunityUpdateToOneWithWhereWithoutCommentsInput = {
    where?: OpportunityWhereInput
    data: XOR<OpportunityUpdateWithoutCommentsInput, OpportunityUncheckedUpdateWithoutCommentsInput>
  }

  export type OpportunityUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    creator?: UserUpdateOneRequiredWithoutOpportunitiesNestedInput
    likes?: OpportunityLikeUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityUncheckedUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    creatorId?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    likes?: OpportunityLikeUncheckedUpdateManyWithoutOpportunityNestedInput
  }

  export type EventLikeCreateWithoutEventInput = {
    id?: string
    user: UserCreateNestedOneWithoutEventLikesInput
  }

  export type EventLikeUncheckedCreateWithoutEventInput = {
    id?: string
    userId: string
  }

  export type EventLikeCreateOrConnectWithoutEventInput = {
    where: EventLikeWhereUniqueInput
    create: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput>
  }

  export type EventLikeCreateManyEventInputEnvelope = {
    data: EventLikeCreateManyEventInput | EventLikeCreateManyEventInput[]
    skipDuplicates?: boolean
  }

  export type EventCommentCreateWithoutEventInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutEventCommentsInput
  }

  export type EventCommentUncheckedCreateWithoutEventInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type EventCommentCreateOrConnectWithoutEventInput = {
    where: EventCommentWhereUniqueInput
    create: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput>
  }

  export type EventCommentCreateManyEventInputEnvelope = {
    data: EventCommentCreateManyEventInput | EventCommentCreateManyEventInput[]
    skipDuplicates?: boolean
  }

  export type EventLikeUpsertWithWhereUniqueWithoutEventInput = {
    where: EventLikeWhereUniqueInput
    update: XOR<EventLikeUpdateWithoutEventInput, EventLikeUncheckedUpdateWithoutEventInput>
    create: XOR<EventLikeCreateWithoutEventInput, EventLikeUncheckedCreateWithoutEventInput>
  }

  export type EventLikeUpdateWithWhereUniqueWithoutEventInput = {
    where: EventLikeWhereUniqueInput
    data: XOR<EventLikeUpdateWithoutEventInput, EventLikeUncheckedUpdateWithoutEventInput>
  }

  export type EventLikeUpdateManyWithWhereWithoutEventInput = {
    where: EventLikeScalarWhereInput
    data: XOR<EventLikeUpdateManyMutationInput, EventLikeUncheckedUpdateManyWithoutEventInput>
  }

  export type EventCommentUpsertWithWhereUniqueWithoutEventInput = {
    where: EventCommentWhereUniqueInput
    update: XOR<EventCommentUpdateWithoutEventInput, EventCommentUncheckedUpdateWithoutEventInput>
    create: XOR<EventCommentCreateWithoutEventInput, EventCommentUncheckedCreateWithoutEventInput>
  }

  export type EventCommentUpdateWithWhereUniqueWithoutEventInput = {
    where: EventCommentWhereUniqueInput
    data: XOR<EventCommentUpdateWithoutEventInput, EventCommentUncheckedUpdateWithoutEventInput>
  }

  export type EventCommentUpdateManyWithWhereWithoutEventInput = {
    where: EventCommentScalarWhereInput
    data: XOR<EventCommentUpdateManyMutationInput, EventCommentUncheckedUpdateManyWithoutEventInput>
  }

  export type UserCreateWithoutEventLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutEventLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutEventLikesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEventLikesInput, UserUncheckedCreateWithoutEventLikesInput>
  }

  export type EventCreateWithoutLikesInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    comments?: EventCommentCreateNestedManyWithoutEventInput
  }

  export type EventUncheckedCreateWithoutLikesInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    comments?: EventCommentUncheckedCreateNestedManyWithoutEventInput
  }

  export type EventCreateOrConnectWithoutLikesInput = {
    where: EventWhereUniqueInput
    create: XOR<EventCreateWithoutLikesInput, EventUncheckedCreateWithoutLikesInput>
  }

  export type UserUpsertWithoutEventLikesInput = {
    update: XOR<UserUpdateWithoutEventLikesInput, UserUncheckedUpdateWithoutEventLikesInput>
    create: XOR<UserCreateWithoutEventLikesInput, UserUncheckedCreateWithoutEventLikesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEventLikesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEventLikesInput, UserUncheckedUpdateWithoutEventLikesInput>
  }

  export type UserUpdateWithoutEventLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutEventLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type EventUpsertWithoutLikesInput = {
    update: XOR<EventUpdateWithoutLikesInput, EventUncheckedUpdateWithoutLikesInput>
    create: XOR<EventCreateWithoutLikesInput, EventUncheckedCreateWithoutLikesInput>
    where?: EventWhereInput
  }

  export type EventUpdateToOneWithWhereWithoutLikesInput = {
    where?: EventWhereInput
    data: XOR<EventUpdateWithoutLikesInput, EventUncheckedUpdateWithoutLikesInput>
  }

  export type EventUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    comments?: EventCommentUpdateManyWithoutEventNestedInput
  }

  export type EventUncheckedUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    comments?: EventCommentUncheckedUpdateManyWithoutEventNestedInput
  }

  export type UserCreateWithoutEventCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutEventCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutEventCommentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutEventCommentsInput, UserUncheckedCreateWithoutEventCommentsInput>
  }

  export type EventCreateWithoutCommentsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    likes?: EventLikeCreateNestedManyWithoutEventInput
  }

  export type EventUncheckedCreateWithoutCommentsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    active?: boolean
    images?: EventCreateimagesInput | string[]
    likes?: EventLikeUncheckedCreateNestedManyWithoutEventInput
  }

  export type EventCreateOrConnectWithoutCommentsInput = {
    where: EventWhereUniqueInput
    create: XOR<EventCreateWithoutCommentsInput, EventUncheckedCreateWithoutCommentsInput>
  }

  export type UserUpsertWithoutEventCommentsInput = {
    update: XOR<UserUpdateWithoutEventCommentsInput, UserUncheckedUpdateWithoutEventCommentsInput>
    create: XOR<UserCreateWithoutEventCommentsInput, UserUncheckedCreateWithoutEventCommentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutEventCommentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutEventCommentsInput, UserUncheckedUpdateWithoutEventCommentsInput>
  }

  export type UserUpdateWithoutEventCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutEventCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type EventUpsertWithoutCommentsInput = {
    update: XOR<EventUpdateWithoutCommentsInput, EventUncheckedUpdateWithoutCommentsInput>
    create: XOR<EventCreateWithoutCommentsInput, EventUncheckedCreateWithoutCommentsInput>
    where?: EventWhereInput
  }

  export type EventUpdateToOneWithWhereWithoutCommentsInput = {
    where?: EventWhereInput
    data: XOR<EventUpdateWithoutCommentsInput, EventUncheckedUpdateWithoutCommentsInput>
  }

  export type EventUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    likes?: EventLikeUpdateManyWithoutEventNestedInput
  }

  export type EventUncheckedUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: EventUpdateimagesInput | string[]
    likes?: EventLikeUncheckedUpdateManyWithoutEventNestedInput
  }

  export type AppointmentLikeCreateWithoutAppointmentInput = {
    id?: string
    user: UserCreateNestedOneWithoutAppointmentLikesInput
  }

  export type AppointmentLikeUncheckedCreateWithoutAppointmentInput = {
    id?: string
    userId: string
  }

  export type AppointmentLikeCreateOrConnectWithoutAppointmentInput = {
    where: AppointmentLikeWhereUniqueInput
    create: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentLikeCreateManyAppointmentInputEnvelope = {
    data: AppointmentLikeCreateManyAppointmentInput | AppointmentLikeCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentCommentCreateWithoutAppointmentInput = {
    id?: string
    content: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutAppointmentCommentsInput
  }

  export type AppointmentCommentUncheckedCreateWithoutAppointmentInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type AppointmentCommentCreateOrConnectWithoutAppointmentInput = {
    where: AppointmentCommentWhereUniqueInput
    create: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentCommentCreateManyAppointmentInputEnvelope = {
    data: AppointmentCommentCreateManyAppointmentInput | AppointmentCommentCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentRegistrationCreateWithoutAppointmentInput = {
    id?: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutAppointmentsRegistrationsInput
  }

  export type AppointmentRegistrationUncheckedCreateWithoutAppointmentInput = {
    id?: string
    userId: string
    createdAt?: Date | string
  }

  export type AppointmentRegistrationCreateOrConnectWithoutAppointmentInput = {
    where: AppointmentRegistrationWhereUniqueInput
    create: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentRegistrationCreateManyAppointmentInputEnvelope = {
    data: AppointmentRegistrationCreateManyAppointmentInput | AppointmentRegistrationCreateManyAppointmentInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentLikeUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentLikeWhereUniqueInput
    update: XOR<AppointmentLikeUpdateWithoutAppointmentInput, AppointmentLikeUncheckedUpdateWithoutAppointmentInput>
    create: XOR<AppointmentLikeCreateWithoutAppointmentInput, AppointmentLikeUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentLikeUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentLikeWhereUniqueInput
    data: XOR<AppointmentLikeUpdateWithoutAppointmentInput, AppointmentLikeUncheckedUpdateWithoutAppointmentInput>
  }

  export type AppointmentLikeUpdateManyWithWhereWithoutAppointmentInput = {
    where: AppointmentLikeScalarWhereInput
    data: XOR<AppointmentLikeUpdateManyMutationInput, AppointmentLikeUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type AppointmentCommentUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentCommentWhereUniqueInput
    update: XOR<AppointmentCommentUpdateWithoutAppointmentInput, AppointmentCommentUncheckedUpdateWithoutAppointmentInput>
    create: XOR<AppointmentCommentCreateWithoutAppointmentInput, AppointmentCommentUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentCommentUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentCommentWhereUniqueInput
    data: XOR<AppointmentCommentUpdateWithoutAppointmentInput, AppointmentCommentUncheckedUpdateWithoutAppointmentInput>
  }

  export type AppointmentCommentUpdateManyWithWhereWithoutAppointmentInput = {
    where: AppointmentCommentScalarWhereInput
    data: XOR<AppointmentCommentUpdateManyMutationInput, AppointmentCommentUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type AppointmentRegistrationUpsertWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentRegistrationWhereUniqueInput
    update: XOR<AppointmentRegistrationUpdateWithoutAppointmentInput, AppointmentRegistrationUncheckedUpdateWithoutAppointmentInput>
    create: XOR<AppointmentRegistrationCreateWithoutAppointmentInput, AppointmentRegistrationUncheckedCreateWithoutAppointmentInput>
  }

  export type AppointmentRegistrationUpdateWithWhereUniqueWithoutAppointmentInput = {
    where: AppointmentRegistrationWhereUniqueInput
    data: XOR<AppointmentRegistrationUpdateWithoutAppointmentInput, AppointmentRegistrationUncheckedUpdateWithoutAppointmentInput>
  }

  export type AppointmentRegistrationUpdateManyWithWhereWithoutAppointmentInput = {
    where: AppointmentRegistrationScalarWhereInput
    data: XOR<AppointmentRegistrationUpdateManyMutationInput, AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentInput>
  }

  export type UserCreateWithoutAppointmentLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentLikesInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAppointmentLikesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAppointmentLikesInput, UserUncheckedCreateWithoutAppointmentLikesInput>
  }

  export type AppointmentCreateWithoutLikesInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    comments?: AppointmentCommentCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutLikesInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    comments?: AppointmentCommentUncheckedCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutLikesInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutLikesInput, AppointmentUncheckedCreateWithoutLikesInput>
  }

  export type UserUpsertWithoutAppointmentLikesInput = {
    update: XOR<UserUpdateWithoutAppointmentLikesInput, UserUncheckedUpdateWithoutAppointmentLikesInput>
    create: XOR<UserCreateWithoutAppointmentLikesInput, UserUncheckedCreateWithoutAppointmentLikesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAppointmentLikesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAppointmentLikesInput, UserUncheckedUpdateWithoutAppointmentLikesInput>
  }

  export type UserUpdateWithoutAppointmentLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentUpsertWithoutLikesInput = {
    update: XOR<AppointmentUpdateWithoutLikesInput, AppointmentUncheckedUpdateWithoutLikesInput>
    create: XOR<AppointmentCreateWithoutLikesInput, AppointmentUncheckedCreateWithoutLikesInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutLikesInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutLikesInput, AppointmentUncheckedUpdateWithoutLikesInput>
  }

  export type AppointmentUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    comments?: AppointmentCommentUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    comments?: AppointmentCommentUncheckedUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserCreateWithoutAppointmentCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentCommentsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAppointmentCommentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAppointmentCommentsInput, UserUncheckedCreateWithoutAppointmentCommentsInput>
  }

  export type AppointmentCreateWithoutCommentsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutCommentsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeUncheckedCreateNestedManyWithoutAppointmentInput
    registrations?: AppointmentRegistrationUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutCommentsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutCommentsInput, AppointmentUncheckedCreateWithoutCommentsInput>
  }

  export type UserUpsertWithoutAppointmentCommentsInput = {
    update: XOR<UserUpdateWithoutAppointmentCommentsInput, UserUncheckedUpdateWithoutAppointmentCommentsInput>
    create: XOR<UserCreateWithoutAppointmentCommentsInput, UserUncheckedCreateWithoutAppointmentCommentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAppointmentCommentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAppointmentCommentsInput, UserUncheckedUpdateWithoutAppointmentCommentsInput>
  }

  export type UserUpdateWithoutAppointmentCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentUpsertWithoutCommentsInput = {
    update: XOR<AppointmentUpdateWithoutCommentsInput, AppointmentUncheckedUpdateWithoutCommentsInput>
    create: XOR<AppointmentCreateWithoutCommentsInput, AppointmentUncheckedCreateWithoutCommentsInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutCommentsInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutCommentsInput, AppointmentUncheckedUpdateWithoutCommentsInput>
  }

  export type AppointmentUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUncheckedUpdateManyWithoutAppointmentNestedInput
    registrations?: AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type UserCreateWithoutAppointmentsRegistrationsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    city?: CityCreateNestedOneWithoutUsersInput
    position?: PositionCreateNestedOneWithoutUsersInput
    company?: CompanyCreateNestedOneWithoutUsersInput
    college?: CollegeCreateNestedOneWithoutUserInput
    province?: ProvinceCreateNestedOneWithoutUserInput
    mandate?: MandateCreateNestedOneWithoutUserInput
    connectionsSent?: ConnectionCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeCreateNestedManyWithoutUserInput
    eventComments?: EventCommentCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentCreateNestedManyWithoutUserInput
    notifications?: NotificationCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAppointmentsRegistrationsInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
    connectionsSent?: ConnectionUncheckedCreateNestedManyWithoutSenderInput
    connectionsReceived?: ConnectionUncheckedCreateNestedManyWithoutReceiverInput
    messagesSent?: MessageUncheckedCreateNestedManyWithoutSenderInput
    messagesReceived?: MessageUncheckedCreateNestedManyWithoutReceiverInput
    opportunities?: OpportunityUncheckedCreateNestedManyWithoutCreatorInput
    opportunityLikes?: OpportunityLikeUncheckedCreateNestedManyWithoutUserInput
    opportunityComments?: OpportunityCommentUncheckedCreateNestedManyWithoutUserInput
    eventLikes?: EventLikeUncheckedCreateNestedManyWithoutUserInput
    eventComments?: EventCommentUncheckedCreateNestedManyWithoutUserInput
    appointmentLikes?: AppointmentLikeUncheckedCreateNestedManyWithoutUserInput
    appointmentComments?: AppointmentCommentUncheckedCreateNestedManyWithoutUserInput
    notifications?: NotificationUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAppointmentsRegistrationsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAppointmentsRegistrationsInput, UserUncheckedCreateWithoutAppointmentsRegistrationsInput>
  }

  export type AppointmentCreateWithoutRegistrationsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeCreateNestedManyWithoutAppointmentInput
    comments?: AppointmentCommentCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutRegistrationsInput = {
    id?: string
    title: string
    briefDescription: string
    description: string
    date: Date | string
    time: string
    activationDate: Date | string
    address: string
    active?: boolean
    images?: AppointmentCreateimagesInput | string[]
    likes?: AppointmentLikeUncheckedCreateNestedManyWithoutAppointmentInput
    comments?: AppointmentCommentUncheckedCreateNestedManyWithoutAppointmentInput
  }

  export type AppointmentCreateOrConnectWithoutRegistrationsInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutRegistrationsInput, AppointmentUncheckedCreateWithoutRegistrationsInput>
  }

  export type UserUpsertWithoutAppointmentsRegistrationsInput = {
    update: XOR<UserUpdateWithoutAppointmentsRegistrationsInput, UserUncheckedUpdateWithoutAppointmentsRegistrationsInput>
    create: XOR<UserCreateWithoutAppointmentsRegistrationsInput, UserUncheckedCreateWithoutAppointmentsRegistrationsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAppointmentsRegistrationsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAppointmentsRegistrationsInput, UserUncheckedUpdateWithoutAppointmentsRegistrationsInput>
  }

  export type UserUpdateWithoutAppointmentsRegistrationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAppointmentsRegistrationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentUpsertWithoutRegistrationsInput = {
    update: XOR<AppointmentUpdateWithoutRegistrationsInput, AppointmentUncheckedUpdateWithoutRegistrationsInput>
    create: XOR<AppointmentCreateWithoutRegistrationsInput, AppointmentUncheckedCreateWithoutRegistrationsInput>
    where?: AppointmentWhereInput
  }

  export type AppointmentUpdateToOneWithWhereWithoutRegistrationsInput = {
    where?: AppointmentWhereInput
    data: XOR<AppointmentUpdateWithoutRegistrationsInput, AppointmentUncheckedUpdateWithoutRegistrationsInput>
  }

  export type AppointmentUpdateWithoutRegistrationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUpdateManyWithoutAppointmentNestedInput
    comments?: AppointmentCommentUpdateManyWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutRegistrationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    briefDescription?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: StringFieldUpdateOperationsInput | string
    activationDate?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    images?: AppointmentUpdateimagesInput | string[]
    likes?: AppointmentLikeUncheckedUpdateManyWithoutAppointmentNestedInput
    comments?: AppointmentCommentUncheckedUpdateManyWithoutAppointmentNestedInput
  }

  export type CategoryCreateWithoutEditionsInput = {
    id?: string
    name: string
    nameAr: string
  }

  export type CategoryUncheckedCreateWithoutEditionsInput = {
    id?: string
    name: string
    nameAr: string
  }

  export type CategoryCreateOrConnectWithoutEditionsInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutEditionsInput, CategoryUncheckedCreateWithoutEditionsInput>
  }

  export type CategoryUpsertWithoutEditionsInput = {
    update: XOR<CategoryUpdateWithoutEditionsInput, CategoryUncheckedUpdateWithoutEditionsInput>
    create: XOR<CategoryCreateWithoutEditionsInput, CategoryUncheckedCreateWithoutEditionsInput>
    where?: CategoryWhereInput
  }

  export type CategoryUpdateToOneWithWhereWithoutEditionsInput = {
    where?: CategoryWhereInput
    data: XOR<CategoryUpdateWithoutEditionsInput, CategoryUncheckedUpdateWithoutEditionsInput>
  }

  export type CategoryUpdateWithoutEditionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
  }

  export type CategoryUncheckedUpdateWithoutEditionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    nameAr?: StringFieldUpdateOperationsInput | string
  }

  export type CompanyCreateManyTurnoverInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type CompanyUpdateWithoutTurnoverInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCompaniesNestedInput
    contactPosition?: PositionUpdateOneWithoutCompaniesNestedInput
    nEmployees?: NEmployeesUpdateOneWithoutCompaniesNestedInput
    users?: UserUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateWithoutTurnoverInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateManyWithoutTurnoverInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CompanyCreateManyNEmployeesInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type CompanyUpdateWithoutNEmployeesInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCompaniesNestedInput
    contactPosition?: PositionUpdateOneWithoutCompaniesNestedInput
    turnover?: TurnoverUpdateOneWithoutCompaniesNestedInput
    users?: UserUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateWithoutNEmployeesInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateManyWithoutNEmployeesInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateManyCityInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type CompanyCreateManyCityInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactPositionId?: string | null
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type UserUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CompanyUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    contactPosition?: PositionUpdateOneWithoutCompaniesNestedInput
    turnover?: TurnoverUpdateOneWithoutCompaniesNestedInput
    nEmployees?: NEmployeesUpdateOneWithoutCompaniesNestedInput
    users?: UserUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPositionId?: NullableStringFieldUpdateOperationsInput | string | null
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateManyPositionInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type CompanyCreateManyContactPositionInput = {
    id?: string
    logo?: string | null
    name: string
    legalForm?: $Enums.LegalForm
    cityId?: string | null
    address: string
    phoneNumber: string
    fax: string
    email: string
    website: string
    linkedin: string
    facebook: string
    contactFirstName: string
    contactLastName: string
    contactEmail: string
    contactLinkedin: string
    contactFacebook: string
    businessLicense: string
    numRC: string
    numICE: string
    capital?: number | null
    turnoverId?: string | null
    nEmployeesId?: string | null
    activitiesFamilies?: CompanyCreateactivitiesFamiliesInput | string[]
    activities?: CompanyCreateactivitiesInput | string[]
    importCountries?: CompanyCreateimportCountriesInput | string[]
    exportCountries?: CompanyCreateexportCountriesInput | string[]
    verified?: boolean
    active?: boolean
    partner?: boolean
    contributor?: boolean
    createdAt?: Date | string
  }

  export type ElectedMemberCreateManyPositionInput = {
    id?: string
    image?: string | null
    fullName: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type UserUpdateWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CompanyUpdateWithoutContactPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCompaniesNestedInput
    turnover?: TurnoverUpdateOneWithoutCompaniesNestedInput
    nEmployees?: NEmployeesUpdateOneWithoutCompaniesNestedInput
    users?: UserUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateWithoutContactPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    users?: UserUncheckedUpdateManyWithoutCompanyNestedInput
  }

  export type CompanyUncheckedUpdateManyWithoutContactPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    logo?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    legalForm?: EnumLegalFormFieldUpdateOperationsInput | $Enums.LegalForm
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    website?: StringFieldUpdateOperationsInput | string
    linkedin?: StringFieldUpdateOperationsInput | string
    facebook?: StringFieldUpdateOperationsInput | string
    contactFirstName?: StringFieldUpdateOperationsInput | string
    contactLastName?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactLinkedin?: StringFieldUpdateOperationsInput | string
    contactFacebook?: StringFieldUpdateOperationsInput | string
    businessLicense?: StringFieldUpdateOperationsInput | string
    numRC?: StringFieldUpdateOperationsInput | string
    numICE?: StringFieldUpdateOperationsInput | string
    capital?: NullableFloatFieldUpdateOperationsInput | number | null
    turnoverId?: NullableStringFieldUpdateOperationsInput | string | null
    nEmployeesId?: NullableStringFieldUpdateOperationsInput | string | null
    activitiesFamilies?: CompanyUpdateactivitiesFamiliesInput | string[]
    activities?: CompanyUpdateactivitiesInput | string[]
    importCountries?: CompanyUpdateimportCountriesInput | string[]
    exportCountries?: CompanyUpdateexportCountriesInput | string[]
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    partner?: BoolFieldUpdateOperationsInput | boolean
    contributor?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ElectedMemberUpdateWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutPositionInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ActivityCreateManyActivityFamilyInput = {
    id?: string
    name: string
  }

  export type ElectedMemberCreateManyActivityFamilyInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ActivityUpdateWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUpdateManyWithoutActivityNestedInput
  }

  export type ActivityUncheckedUpdateWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    electedMembers?: ElectedMemberUncheckedUpdateManyWithoutActivityNestedInput
  }

  export type ActivityUncheckedUpdateManyWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUpdateWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutActivityFamilyInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberCreateManyActivityInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type ElectedMemberUpdateWithoutActivityInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutActivityInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutActivityInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberCreateManyProvinceInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type UserCreateManyProvinceInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type ElectedMemberUpdateWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpdateWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutProvinceInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EditionCreateManyCategoryInput = {
    id?: string
    title: string
    document: string
    image?: string | null
  }

  export type EditionUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type EditionUncheckedUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type EditionUncheckedUpdateManyWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    document?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ElectedMemberCreateManyMandateInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    collegeId: string
    provinceId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type UserCreateManyMandateInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type ElectedMemberUpdateWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    college?: CollegeUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    collegeId?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpdateWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutMandateInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ElectedMemberCreateManyCollegeInput = {
    id?: string
    image?: string | null
    fullName: string
    positionId: string
    activityFamilyId: string
    activityId: string
    phoneNumber: string
    gsm: string
    fax: string
    email: string
    adresse: string
    provinceId: string
    mandateId: string
    commissions?: ElectedMemberCreatecommissionsInput | string[]
    details: string
  }

  export type UserCreateManyCollegeInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    companyId?: string | null
    department?: string | null
    service?: string | null
    adresse?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type ElectedMemberUpdateWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
    position?: PositionUpdateOneRequiredWithoutElectedMembersNestedInput
    activityFamily?: ActivityFamilyUpdateOneRequiredWithoutElectedMembersNestedInput
    activity?: ActivityUpdateOneRequiredWithoutElectedMembersNestedInput
    province?: ProvinceUpdateOneRequiredWithoutElectedMembersNestedInput
    mandate?: MandateUpdateOneRequiredWithoutElectedMembersNestedInput
  }

  export type ElectedMemberUncheckedUpdateWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type ElectedMemberUncheckedUpdateManyWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    fullName?: StringFieldUpdateOperationsInput | string
    positionId?: StringFieldUpdateOperationsInput | string
    activityFamilyId?: StringFieldUpdateOperationsInput | string
    activityId?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    gsm?: StringFieldUpdateOperationsInput | string
    fax?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    adresse?: StringFieldUpdateOperationsInput | string
    provinceId?: StringFieldUpdateOperationsInput | string
    mandateId?: StringFieldUpdateOperationsInput | string
    commissions?: ElectedMemberUpdatecommissionsInput | string[]
    details?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpdateWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    company?: CompanyUpdateOneWithoutUsersNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutCollegeInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    companyId?: NullableStringFieldUpdateOperationsInput | string | null
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionCreateManySenderInput = {
    id?: string
    receiverId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type ConnectionCreateManyReceiverInput = {
    id?: string
    senderId: string
    accepted?: boolean
    createdAt?: Date | string
  }

  export type MessageCreateManySenderInput = {
    id?: string
    receiverId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type MessageCreateManyReceiverInput = {
    id?: string
    senderId: string
    message: string
    read?: boolean
    createdAt?: Date | string
  }

  export type OpportunityCreateManyCreatorInput = {
    id?: string
    title: string
    description: string
    companyName: string
    activitiesFamilies?: OpportunityCreateactivitiesFamiliesInput | string[]
    activities?: OpportunityCreateactivitiesInput | string[]
    country: string
    address: string
    requirements: string
    contactEmail: string
    contactPhoneNumber: string
    document?: string | null
    verified?: boolean
    active?: boolean
    validityDate?: Date | string | null
    createdAt?: Date | string
  }

  export type OpportunityLikeCreateManyUserInput = {
    id?: string
    opportunityId: string
  }

  export type OpportunityCommentCreateManyUserInput = {
    id?: string
    content: string
    opportunityId: string
    createdAt?: Date | string
  }

  export type EventLikeCreateManyUserInput = {
    id?: string
    eventId: string
  }

  export type EventCommentCreateManyUserInput = {
    id?: string
    content: string
    eventId: string
    createdAt?: Date | string
  }

  export type AppointmentLikeCreateManyUserInput = {
    id?: string
    appointmentId: string
  }

  export type AppointmentCommentCreateManyUserInput = {
    id?: string
    content: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type NotificationCreateManyUserInput = {
    id?: string
    title: string
    content: string
    source: $Enums.Source
    createdAt?: Date | string
    isRead?: boolean
  }

  export type AppointmentRegistrationCreateManyUserInput = {
    id?: string
    appointmentId: string
    createdAt?: Date | string
  }

  export type ConnectionUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    receiver?: UserUpdateOneRequiredWithoutConnectionsReceivedNestedInput
  }

  export type ConnectionUncheckedUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionUncheckedUpdateManyWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionUpdateWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sender?: UserUpdateOneRequiredWithoutConnectionsSentNestedInput
  }

  export type ConnectionUncheckedUpdateWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ConnectionUncheckedUpdateManyWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    accepted?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    receiver?: UserUpdateOneRequiredWithoutMessagesReceivedNestedInput
  }

  export type MessageUncheckedUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageUncheckedUpdateManyWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    receiverId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageUpdateWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sender?: UserUpdateOneRequiredWithoutMessagesSentNestedInput
  }

  export type MessageUncheckedUpdateWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessageUncheckedUpdateManyWithoutReceiverInput = {
    id?: StringFieldUpdateOperationsInput | string
    senderId?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    read?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityUpdateWithoutCreatorInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    likes?: OpportunityLikeUpdateManyWithoutOpportunityNestedInput
    comments?: OpportunityCommentUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityUncheckedUpdateWithoutCreatorInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    likes?: OpportunityLikeUncheckedUpdateManyWithoutOpportunityNestedInput
    comments?: OpportunityCommentUncheckedUpdateManyWithoutOpportunityNestedInput
  }

  export type OpportunityUncheckedUpdateManyWithoutCreatorInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    companyName?: StringFieldUpdateOperationsInput | string
    activitiesFamilies?: OpportunityUpdateactivitiesFamiliesInput | string[]
    activities?: OpportunityUpdateactivitiesInput | string[]
    country?: StringFieldUpdateOperationsInput | string
    address?: StringFieldUpdateOperationsInput | string
    requirements?: StringFieldUpdateOperationsInput | string
    contactEmail?: StringFieldUpdateOperationsInput | string
    contactPhoneNumber?: StringFieldUpdateOperationsInput | string
    document?: NullableStringFieldUpdateOperationsInput | string | null
    verified?: BoolFieldUpdateOperationsInput | boolean
    active?: BoolFieldUpdateOperationsInput | boolean
    validityDate?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityLikeUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    opportunity?: OpportunityUpdateOneRequiredWithoutLikesNestedInput
  }

  export type OpportunityLikeUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityLikeUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityCommentUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    opportunity?: OpportunityUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type OpportunityCommentUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityCommentUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    opportunityId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLikeUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    event?: EventUpdateOneRequiredWithoutLikesNestedInput
  }

  export type EventLikeUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
  }

  export type EventLikeUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
  }

  export type EventCommentUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    event?: EventUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type EventCommentUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCommentUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    eventId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentLikeUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    appointment?: AppointmentUpdateOneRequiredWithoutLikesNestedInput
  }

  export type AppointmentLikeUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentLikeUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentCommentUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointment?: AppointmentUpdateOneRequiredWithoutCommentsNestedInput
  }

  export type AppointmentCommentUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCommentUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NotificationUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    source?: EnumSourceFieldUpdateOperationsInput | $Enums.Source
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    isRead?: BoolFieldUpdateOperationsInput | boolean
  }

  export type AppointmentRegistrationUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    appointment?: AppointmentUpdateOneRequiredWithoutRegistrationsNestedInput
  }

  export type AppointmentRegistrationUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    appointmentId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateManyCompanyInput = {
    id?: string
    civility?: $Enums.Civility
    firstName: string
    lastName: string
    email: string
    password: string
    cityId?: string | null
    positionId?: string | null
    phoneNumber: string
    expertiseAreas?: UserCreateexpertiseAreasInput | string[]
    interestAreas?: UserCreateinterestAreasInput | string[]
    bio: string
    department?: string | null
    service?: string | null
    adresse?: string | null
    collegeId?: string | null
    provinceId?: string | null
    mandateId?: string | null
    commissions?: UserCreatecommissionsInput | string[]
    details?: string | null
    active?: boolean
    member?: boolean
    role?: $Enums.Role
    permissions?: UserCreatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: string | null
    resetPasswordAt?: Date | string | null
    loggedInAt?: Date | string | null
    createdAt?: Date | string
  }

  export type UserUpdateWithoutCompanyInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutUsersNestedInput
    position?: PositionUpdateOneWithoutUsersNestedInput
    college?: CollegeUpdateOneWithoutUserNestedInput
    province?: ProvinceUpdateOneWithoutUserNestedInput
    mandate?: MandateUpdateOneWithoutUserNestedInput
    connectionsSent?: ConnectionUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUpdateManyWithoutUserNestedInput
    notifications?: NotificationUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutCompanyInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    connectionsSent?: ConnectionUncheckedUpdateManyWithoutSenderNestedInput
    connectionsReceived?: ConnectionUncheckedUpdateManyWithoutReceiverNestedInput
    messagesSent?: MessageUncheckedUpdateManyWithoutSenderNestedInput
    messagesReceived?: MessageUncheckedUpdateManyWithoutReceiverNestedInput
    opportunities?: OpportunityUncheckedUpdateManyWithoutCreatorNestedInput
    opportunityLikes?: OpportunityLikeUncheckedUpdateManyWithoutUserNestedInput
    opportunityComments?: OpportunityCommentUncheckedUpdateManyWithoutUserNestedInput
    eventLikes?: EventLikeUncheckedUpdateManyWithoutUserNestedInput
    eventComments?: EventCommentUncheckedUpdateManyWithoutUserNestedInput
    appointmentLikes?: AppointmentLikeUncheckedUpdateManyWithoutUserNestedInput
    appointmentComments?: AppointmentCommentUncheckedUpdateManyWithoutUserNestedInput
    notifications?: NotificationUncheckedUpdateManyWithoutUserNestedInput
    appointmentsRegistrations?: AppointmentRegistrationUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutCompanyInput = {
    id?: StringFieldUpdateOperationsInput | string
    civility?: EnumCivilityFieldUpdateOperationsInput | $Enums.Civility
    firstName?: StringFieldUpdateOperationsInput | string
    lastName?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    positionId?: NullableStringFieldUpdateOperationsInput | string | null
    phoneNumber?: StringFieldUpdateOperationsInput | string
    expertiseAreas?: UserUpdateexpertiseAreasInput | string[]
    interestAreas?: UserUpdateinterestAreasInput | string[]
    bio?: StringFieldUpdateOperationsInput | string
    department?: NullableStringFieldUpdateOperationsInput | string | null
    service?: NullableStringFieldUpdateOperationsInput | string | null
    adresse?: NullableStringFieldUpdateOperationsInput | string | null
    collegeId?: NullableStringFieldUpdateOperationsInput | string | null
    provinceId?: NullableStringFieldUpdateOperationsInput | string | null
    mandateId?: NullableStringFieldUpdateOperationsInput | string | null
    commissions?: UserUpdatecommissionsInput | string[]
    details?: NullableStringFieldUpdateOperationsInput | string | null
    active?: BoolFieldUpdateOperationsInput | boolean
    member?: BoolFieldUpdateOperationsInput | boolean
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    permissions?: UserUpdatepermissionsInput | $Enums.Permission[]
    resetPasswordCode?: NullableStringFieldUpdateOperationsInput | string | null
    resetPasswordAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    loggedInAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityLikeCreateManyOpportunityInput = {
    id?: string
    userId: string
  }

  export type OpportunityCommentCreateManyOpportunityInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type OpportunityLikeUpdateWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutOpportunityLikesNestedInput
  }

  export type OpportunityLikeUncheckedUpdateWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityLikeUncheckedUpdateManyWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type OpportunityCommentUpdateWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutOpportunityCommentsNestedInput
  }

  export type OpportunityCommentUncheckedUpdateWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OpportunityCommentUncheckedUpdateManyWithoutOpportunityInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLikeCreateManyEventInput = {
    id?: string
    userId: string
  }

  export type EventCommentCreateManyEventInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type EventLikeUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutEventLikesNestedInput
  }

  export type EventLikeUncheckedUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type EventLikeUncheckedUpdateManyWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type EventCommentUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutEventCommentsNestedInput
  }

  export type EventCommentUncheckedUpdateWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventCommentUncheckedUpdateManyWithoutEventInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentLikeCreateManyAppointmentInput = {
    id?: string
    userId: string
  }

  export type AppointmentCommentCreateManyAppointmentInput = {
    id?: string
    content: string
    userId: string
    createdAt?: Date | string
  }

  export type AppointmentRegistrationCreateManyAppointmentInput = {
    id?: string
    userId: string
    createdAt?: Date | string
  }

  export type AppointmentLikeUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutAppointmentLikesNestedInput
  }

  export type AppointmentLikeUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentLikeUncheckedUpdateManyWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AppointmentCommentUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAppointmentCommentsNestedInput
  }

  export type AppointmentCommentUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCommentUncheckedUpdateManyWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    content?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAppointmentsRegistrationsNestedInput
  }

  export type AppointmentRegistrationUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentRegistrationUncheckedUpdateManyWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use TurnoverCountOutputTypeDefaultArgs instead
     */
    export type TurnoverCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TurnoverCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NEmployeesCountOutputTypeDefaultArgs instead
     */
    export type NEmployeesCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NEmployeesCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CityCountOutputTypeDefaultArgs instead
     */
    export type CityCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CityCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PositionCountOutputTypeDefaultArgs instead
     */
    export type PositionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PositionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ActivityFamilyCountOutputTypeDefaultArgs instead
     */
    export type ActivityFamilyCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ActivityFamilyCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ActivityCountOutputTypeDefaultArgs instead
     */
    export type ActivityCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ActivityCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProvinceCountOutputTypeDefaultArgs instead
     */
    export type ProvinceCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProvinceCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryCountOutputTypeDefaultArgs instead
     */
    export type CategoryCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MandateCountOutputTypeDefaultArgs instead
     */
    export type MandateCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MandateCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CollegeCountOutputTypeDefaultArgs instead
     */
    export type CollegeCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CollegeCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CompanyCountOutputTypeDefaultArgs instead
     */
    export type CompanyCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CompanyCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OpportunityCountOutputTypeDefaultArgs instead
     */
    export type OpportunityCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OpportunityCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventCountOutputTypeDefaultArgs instead
     */
    export type EventCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentCountOutputTypeDefaultArgs instead
     */
    export type AppointmentCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CcisDefaultArgs instead
     */
    export type CcisArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CcisDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TurnoverDefaultArgs instead
     */
    export type TurnoverArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TurnoverDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NEmployeesDefaultArgs instead
     */
    export type NEmployeesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NEmployeesDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CityDefaultArgs instead
     */
    export type CityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PositionDefaultArgs instead
     */
    export type PositionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PositionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ActivityFamilyDefaultArgs instead
     */
    export type ActivityFamilyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ActivityFamilyDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ActivityDefaultArgs instead
     */
    export type ActivityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ActivityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExpertiseAreaDefaultArgs instead
     */
    export type ExpertiseAreaArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExpertiseAreaDefaultArgs<ExtArgs>
    /**
     * @deprecated Use InterestAreaDefaultArgs instead
     */
    export type InterestAreaArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = InterestAreaDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProvinceDefaultArgs instead
     */
    export type ProvinceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProvinceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryDefaultArgs instead
     */
    export type CategoryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CommissionDefaultArgs instead
     */
    export type CommissionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CommissionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MandateDefaultArgs instead
     */
    export type MandateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MandateDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CollegeDefaultArgs instead
     */
    export type CollegeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CollegeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ElectedMemberDefaultArgs instead
     */
    export type ElectedMemberArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ElectedMemberDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NotificationDefaultArgs instead
     */
    export type NotificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NotificationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CompanyDefaultArgs instead
     */
    export type CompanyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CompanyDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ConnectionDefaultArgs instead
     */
    export type ConnectionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ConnectionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MessageDefaultArgs instead
     */
    export type MessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MessageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OpportunityDefaultArgs instead
     */
    export type OpportunityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OpportunityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OpportunityLikeDefaultArgs instead
     */
    export type OpportunityLikeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OpportunityLikeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OpportunityCommentDefaultArgs instead
     */
    export type OpportunityCommentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OpportunityCommentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventDefaultArgs instead
     */
    export type EventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventLikeDefaultArgs instead
     */
    export type EventLikeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventLikeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventCommentDefaultArgs instead
     */
    export type EventCommentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventCommentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentDefaultArgs instead
     */
    export type AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentLikeDefaultArgs instead
     */
    export type AppointmentLikeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentLikeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentCommentDefaultArgs instead
     */
    export type AppointmentCommentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentCommentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppointmentRegistrationDefaultArgs instead
     */
    export type AppointmentRegistrationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppointmentRegistrationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AlbumDefaultArgs instead
     */
    export type AlbumArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AlbumDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VideoDefaultArgs instead
     */
    export type VideoArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VideoDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EditionDefaultArgs instead
     */
    export type EditionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EditionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TrainingDefaultArgs instead
     */
    export type TrainingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TrainingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FairDefaultArgs instead
     */
    export type FairArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FairDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BusinessPlanDefaultArgs instead
     */
    export type BusinessPlanArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BusinessPlanDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MarketResearchDefaultArgs instead
     */
    export type MarketResearchArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MarketResearchDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NetworkingDefaultArgs instead
     */
    export type NetworkingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NetworkingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SourcingDefaultArgs instead
     */
    export type SourcingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SourcingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProspectingDefaultArgs instead
     */
    export type ProspectingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProspectingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SmsLogDefaultArgs instead
     */
    export type SmsLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SmsLogDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}